From 681eec54ec261fb47672786f449454739a9cab3c Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Thu, 14 Feb 2019 00:16:52 +0100 Subject: [PATCH 01/21] Update to 1.1.97 --- ash/src/vk.rs | 779 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 779 insertions(+) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index a60465d..001baad 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -33202,6 +33202,164 @@ impl<'a> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceDepthStencilResolvePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_depth_resolve_modes: ResolveModeFlagsKHR, + pub supported_stencil_resolve_modes: ResolveModeFlagsKHR, + pub independent_resolve_none: Bool32, + pub independent_resolve: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthStencilResolvePropertiesKHR { + fn default() -> PhysicalDeviceDepthStencilResolvePropertiesKHR { + PhysicalDeviceDepthStencilResolvePropertiesKHR { + s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, + p_next: ::std::ptr::null_mut(), + supported_depth_resolve_modes: ResolveModeFlagsKHR::default(), + supported_stencil_resolve_modes: ResolveModeFlagsKHR::default(), + independent_resolve_none: Bool32::default(), + independent_resolve: Bool32::default(), + } + } +} +impl PhysicalDeviceDepthStencilResolvePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder { + inner: PhysicalDeviceDepthStencilResolvePropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceDepthStencilResolvePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceDepthStencilResolvePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: ResolveModeFlagsKHR, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: ResolveModeFlagsKHR, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + pub fn independent_resolve_none( + mut self, + independent_resolve_none: bool, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.independent_resolve_none = independent_resolve_none.into(); + self + } + pub fn independent_resolve( + mut self, + independent_resolve: bool, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.independent_resolve = independent_resolve.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> + where + T: ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceDepthStencilResolvePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct SubpassDescriptionDepthStencilResolveKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub depth_resolve_mode: ResolveModeFlagsKHR, + pub stencil_resolve_mode: ResolveModeFlagsKHR, + pub p_depth_stencil_resolve_attachment: *const AttachmentReference2KHR, +} +impl ::std::default::Default for SubpassDescriptionDepthStencilResolveKHR { + fn default() -> SubpassDescriptionDepthStencilResolveKHR { + SubpassDescriptionDepthStencilResolveKHR { + s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR, + p_next: ::std::ptr::null(), + depth_resolve_mode: ResolveModeFlagsKHR::default(), + stencil_resolve_mode: ResolveModeFlagsKHR::default(), + p_depth_stencil_resolve_attachment: ::std::ptr::null(), + } + } +} +impl SubpassDescriptionDepthStencilResolveKHR { + pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + SubpassDescriptionDepthStencilResolveKHRBuilder { + inner: SubpassDescriptionDepthStencilResolveKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + inner: SubpassDescriptionDepthStencilResolveKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassDescriptionDepthStencilResolveKHR {} +unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHR {} +impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + type Target = SubpassDescriptionDepthStencilResolveKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + pub fn depth_resolve_mode( + mut self, + depth_resolve_mode: ResolveModeFlagsKHR, + ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + self.inner.depth_resolve_mode = depth_resolve_mode; + self + } + pub fn stencil_resolve_mode( + mut self, + stencil_resolve_mode: ResolveModeFlagsKHR, + ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + self.inner.stencil_resolve_mode = stencil_resolve_mode; + self + } + pub fn depth_stencil_resolve_attachment( + mut self, + depth_stencil_resolve_attachment: &'a AttachmentReference2KHR, + ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; + self + } + pub fn next(mut self, next: &'a T) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> + where + T: ExtendsSubpassDescriptionDepthStencilResolveKHR, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> SubpassDescriptionDepthStencilResolveKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] pub struct ImageViewASTCDecodeModeEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -36822,6 +36980,627 @@ impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map: Bool32, + pub fragment_density_map_dynamic: Bool32, + pub fragment_density_map_non_subsampled_images: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT { + fn default() -> PhysicalDeviceFragmentDensityMapFeaturesEXT { + PhysicalDeviceFragmentDensityMapFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + fragment_density_map: Bool32::default(), + fragment_density_map_dynamic: Bool32::default(), + fragment_density_map_non_subsampled_images: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder { + inner: PhysicalDeviceFragmentDensityMapFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + pub fn fragment_density_map( + mut self, + fragment_density_map: bool, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + self.inner.fragment_density_map = fragment_density_map.into(); + self + } + pub fn fragment_density_map_dynamic( + mut self, + fragment_density_map_dynamic: bool, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into(); + self + } + pub fn fragment_density_map_non_subsampled_images( + mut self, + fragment_density_map_non_subsampled_images: bool, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + self.inner.fragment_density_map_non_subsampled_images = + fragment_density_map_non_subsampled_images.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_fragment_density_texel_size: Extent2D, + pub max_fragment_density_texel_size: Extent2D, + pub fragment_density_invocations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT { + fn default() -> PhysicalDeviceFragmentDensityMapPropertiesEXT { + PhysicalDeviceFragmentDensityMapPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + min_fragment_density_texel_size: Extent2D::default(), + max_fragment_density_texel_size: Extent2D::default(), + fragment_density_invocations: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder { + inner: PhysicalDeviceFragmentDensityMapPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + pub fn min_fragment_density_texel_size( + mut self, + min_fragment_density_texel_size: Extent2D, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size; + self + } + pub fn max_fragment_density_texel_size( + mut self, + max_fragment_density_texel_size: Extent2D, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size; + self + } + pub fn fragment_density_invocations( + mut self, + fragment_density_invocations: bool, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + self.inner.fragment_density_invocations = fragment_density_invocations.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct RenderPassFragmentDensityMapCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_density_map_attachment: AttachmentReference, +} +impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT { + fn default() -> RenderPassFragmentDensityMapCreateInfoEXT { + RenderPassFragmentDensityMapCreateInfoEXT { + s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + fragment_density_map_attachment: AttachmentReference::default(), + } + } +} +impl RenderPassFragmentDensityMapCreateInfoEXT { + pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + RenderPassFragmentDensityMapCreateInfoEXTBuilder { + inner: RenderPassFragmentDensityMapCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + inner: RenderPassFragmentDensityMapCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassFragmentDensityMapCreateInfoEXT {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + type Target = RenderPassFragmentDensityMapCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + pub fn fragment_density_map_attachment( + mut self, + fragment_density_map_attachment: AttachmentReference, + ) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + self.inner.fragment_density_map_attachment = fragment_density_map_attachment; + self + } + pub fn next(mut self, next: &'a T) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> + where + T: ExtendsRenderPassFragmentDensityMapCreateInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub scalar_block_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeaturesEXT { + fn default() -> PhysicalDeviceScalarBlockLayoutFeaturesEXT { + PhysicalDeviceScalarBlockLayoutFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + scalar_block_layout: Bool32::default(), + } + } +} +impl PhysicalDeviceScalarBlockLayoutFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder { + inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceScalarBlockLayoutFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + pub fn scalar_block_layout( + mut self, + scalar_block_layout: bool, + ) -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + self.inner.scalar_block_layout = scalar_block_layout.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceMemoryBudgetPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], + pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], +} +impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT { + fn default() -> PhysicalDeviceMemoryBudgetPropertiesEXT { + PhysicalDeviceMemoryBudgetPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + heap_budget: unsafe { ::std::mem::zeroed() }, + heap_usage: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PhysicalDeviceMemoryBudgetPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + PhysicalDeviceMemoryBudgetPropertiesEXTBuilder { + inner: PhysicalDeviceMemoryBudgetPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryBudgetPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + pub fn heap_budget( + mut self, + heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], + ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + self.inner.heap_budget = heap_budget; + self + } + pub fn heap_usage( + mut self, + heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], + ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + self.inner.heap_usage = heap_usage; + self + } + pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceMemoryPriorityFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_priority: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT { + fn default() -> PhysicalDeviceMemoryPriorityFeaturesEXT { + PhysicalDeviceMemoryPriorityFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + memory_priority: Bool32::default(), + } + } +} +impl PhysicalDeviceMemoryPriorityFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + PhysicalDeviceMemoryPriorityFeaturesEXTBuilder { + inner: PhysicalDeviceMemoryPriorityFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryPriorityFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + pub fn memory_priority( + mut self, + memory_priority: bool, + ) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + self.inner.memory_priority = memory_priority.into(); + self + } + pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct MemoryPriorityAllocateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub priority: f32, +} +impl ::std::default::Default for MemoryPriorityAllocateInfoEXT { + fn default() -> MemoryPriorityAllocateInfoEXT { + MemoryPriorityAllocateInfoEXT { + s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT, + p_next: ::std::ptr::null(), + priority: f32::default(), + } + } +} +impl MemoryPriorityAllocateInfoEXT { + pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> { + MemoryPriorityAllocateInfoEXTBuilder { + inner: MemoryPriorityAllocateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { + inner: MemoryPriorityAllocateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsMemoryPriorityAllocateInfoEXT {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} +impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { + type Target = MemoryPriorityAllocateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> { + pub fn priority(mut self, priority: f32) -> MemoryPriorityAllocateInfoEXTBuilder<'a> { + self.inner.priority = priority; + self + } + pub fn next(mut self, next: &'a T) -> MemoryPriorityAllocateInfoEXTBuilder<'a> + where + T: ExtendsMemoryPriorityAllocateInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> MemoryPriorityAllocateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceBufferAddressFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBufferAddressFeaturesEXT { + fn default() -> PhysicalDeviceBufferAddressFeaturesEXT { + PhysicalDeviceBufferAddressFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + } + } +} +impl PhysicalDeviceBufferAddressFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + PhysicalDeviceBufferAddressFeaturesEXTBuilder { + inner: PhysicalDeviceBufferAddressFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBufferAddressFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceBufferAddressFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferAddressFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBufferAddressFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + pub fn buffer_device_address( + mut self, + buffer_device_address: bool, + ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceBufferAddressFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceBufferAddressFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct BufferDeviceAddressInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferDeviceAddressInfoEXT { + fn default() -> BufferDeviceAddressInfoEXT { + BufferDeviceAddressInfoEXT { + s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO_EXT, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +impl BufferDeviceAddressInfoEXT { + pub fn builder<'a>() -> BufferDeviceAddressInfoEXTBuilder<'a> { + BufferDeviceAddressInfoEXTBuilder { + inner: BufferDeviceAddressInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferDeviceAddressInfoEXTBuilder<'a> { + inner: BufferDeviceAddressInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferDeviceAddressInfoEXT {} +impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoEXTBuilder<'a> { + type Target = BufferDeviceAddressInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferDeviceAddressInfoEXTBuilder<'a> { + pub fn buffer(mut self, buffer: Buffer) -> BufferDeviceAddressInfoEXTBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn next(mut self, next: &'a T) -> BufferDeviceAddressInfoEXTBuilder<'a> + where + T: ExtendsBufferDeviceAddressInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> BufferDeviceAddressInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct BufferDeviceAddressCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_address: DeviceSize, +} +impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT { + fn default() -> BufferDeviceAddressCreateInfoEXT { + BufferDeviceAddressCreateInfoEXT { + s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + device_address: DeviceSize::default(), + } + } +} +impl BufferDeviceAddressCreateInfoEXT { + pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + BufferDeviceAddressCreateInfoEXTBuilder { + inner: BufferDeviceAddressCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { + inner: BufferDeviceAddressCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferDeviceAddressCreateInfoEXT {} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} +impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { + type Target = BufferDeviceAddressCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + pub fn device_address( + mut self, + device_address: DeviceSize, + ) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + self.inner.device_address = device_address; + self + } + pub fn next(mut self, next: &'a T) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> + where + T: ExtendsBufferDeviceAddressCreateInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> BufferDeviceAddressCreateInfoEXT { + self.inner + } +} #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ImageLayout(pub(crate) i32); From 6d72bb547d9746f2c5665d11656e127bf748500f Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 3 Feb 2019 12:48:05 +0100 Subject: [PATCH 02/21] Implement extension chaining --- ash/src/vk.rs | 2420 ++++++++++++++++++++++++++++++++++++++++-- examples/src/lib.rs | 32 +- generator/src/lib.rs | 51 +- 3 files changed, 2382 insertions(+), 121 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 001baad..70af505 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -24365,11 +24365,23 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { self.inner.set = set; self } +<<<<<<< HEAD pub fn next(mut self, next: &'a T) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> where T: ExtendsDescriptorUpdateTemplateCreateInfo, { self.inner.p_next = next as *const T as *const c_void; +======= + pub fn next( + mut self, + next: &'a mut impl ::std::ops::DerefMut, + ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + unsafe { + let ptr = &mut self.inner as *mut _ as *mut c_void; + let last_extension = ExtensionChain::last_chain(ptr); + (*last_extension).p_next = next.deref_mut() as *mut T as *mut c_void; + } +>>>>>>> Implement extension chaining self } pub fn build(self) -> DescriptorUpdateTemplateCreateInfo { @@ -55079,11 +55091,35 @@ fn display_flags( } Ok(()) } +<<<<<<< HEAD impl fmt::Display for CommandBufferLevel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::PRIMARY => Some("PRIMARY"), Self::SECONDARY => Some("SECONDARY"), +======= +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55093,12 +55129,20 @@ impl fmt::Display for CommandBufferLevel { } } } +<<<<<<< HEAD impl fmt::Display for MemoryOverallocationBehaviorAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::DEFAULT => Some("DEFAULT"), Self::ALLOWED => Some("ALLOWED"), Self::DISALLOWED => Some("DISALLOWED"), +======= +impl fmt::Display for CopyAccelerationStructureModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55108,11 +55152,18 @@ impl fmt::Display for MemoryOverallocationBehaviorAMD { } } } +<<<<<<< HEAD impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::INLINE => Some("INLINE"), Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), +======= +impl fmt::Display for AccelerationStructureTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), _ => None, }; if let Some(x) = name { @@ -55122,6 +55173,188 @@ impl fmt::Display for SubpassContents { } } } +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), +>>>>>>> Implement extension chaining + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +<<<<<<< HEAD impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -55129,15 +55362,57 @@ impl fmt::Display for QueryResultFlags { (QueryResultFlags::WAIT.0, "WAIT"), (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), (QueryResultFlags::PARTIAL.0, "PARTIAL"), +======= +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), +>>>>>>> Implement extension chaining ]; display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD impl fmt::Display for GeometryTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::TRIANGLES => Some("TRIANGLES"), Self::AABBS => Some("AABBS"), +======= +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55147,7 +55422,30 @@ impl fmt::Display for GeometryTypeNV { } } } +<<<<<<< HEAD impl fmt::Display for DebugReportObjectTypeEXT { +======= +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { +>>>>>>> Implement extension chaining fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::UNKNOWN => Some("UNKNOWN"), @@ -55196,6 +55494,7 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } +<<<<<<< HEAD impl fmt::Display for SamplerCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -55233,6 +55532,17 @@ impl fmt::Display for DriverIdKHR { Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), +======= +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55242,6 +55552,7 @@ impl fmt::Display for DriverIdKHR { } } } +<<<<<<< HEAD impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -55318,6 +55629,13 @@ impl fmt::Display for SamplerMipmapMode { let name = match *self { Self::NEAREST => Some("NEAREST"), Self::LINEAR => Some("LINEAR"), +======= +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55327,10 +55645,18 @@ impl fmt::Display for SamplerMipmapMode { } } } +<<<<<<< HEAD impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), +======= +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55340,6 +55666,7 @@ impl fmt::Display for DisplayEventTypeEXT { } } } +<<<<<<< HEAD impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -55372,6 +55699,30 @@ impl fmt::Display for RayTracingShaderGroupTypeNV { Self::GENERAL => Some("GENERAL"), Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), +======= +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55379,6 +55730,7 @@ impl fmt::Display for RayTracingShaderGroupTypeNV { } else { write!(f, "{}", self.0) } +<<<<<<< HEAD } } impl fmt::Display for CullModeFlags { @@ -55390,6 +55742,8 @@ impl fmt::Display for CullModeFlags { (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), ]; display_flags(f, KNOWN, self.0) +======= +>>>>>>> Implement extension chaining } } impl fmt::Display for ValidationFeatureDisableEXT { @@ -55411,6 +55765,7 @@ impl fmt::Display for ValidationFeatureDisableEXT { } } } +<<<<<<< HEAD impl fmt::Display for AttachmentDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; @@ -55837,6 +56192,14 @@ impl fmt::Display for DescriptorPoolCreateFlags { display_flags(f, KNOWN, self.0) } } +======= +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: RESERVED_24_EXT . 0 , "RESERVED_24_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +>>>>>>> Implement extension chaining impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -55848,6 +56211,7 @@ impl fmt::Display for CompositeAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD impl fmt::Display for ImageTiling { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -56508,6 +56872,8 @@ impl fmt::Display for BlendOverlapEXT { } } } +======= +>>>>>>> Implement extension chaining impl fmt::Display for CommandBufferResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[( @@ -56517,6 +56883,7 @@ impl fmt::Display for CommandBufferResetFlags { display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD impl fmt::Display for IndirectCommandsTokenTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -56878,10 +57245,24 @@ impl fmt::Display for DescriptorSetLayoutCreateFlags { DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, "UPDATE_AFTER_BIND_POOL_EXT", ), +======= +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), +>>>>>>> Implement extension chaining ]; display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD impl fmt::Display for QueryPipelineStatisticFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57032,6 +57413,8 @@ impl fmt::Display for BlendFactor { } } } +======= +>>>>>>> Implement extension chaining impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57666,6 +58049,7 @@ impl fmt::Display for StructureType { } } } +<<<<<<< HEAD impl fmt::Display for GeometryFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57674,38 +58058,47 @@ impl fmt::Display for GeometryFlagsNV { GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, "NO_DUPLICATE_ANY_HIT_INVOCATION", ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { +======= +impl fmt::Display for StencilFaceFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DisplayPowerStateEXT { +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShadingRatePaletteEntryNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), _ => None, }; if let Some(x) = name { @@ -57715,53 +58108,268 @@ impl fmt::Display for DisplayPowerStateEXT { } } } -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for ExternalFenceHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", ), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", ), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", ), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DebugReportFlagsEXT { +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, + "SHADING_RATE_IMAGE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, + "ACCELERATION_STRUCTURE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, + "ACCELERATION_STRUCTURE_WRITE_NV", + ), + (AccessFlags::RESERVED_24_EXT.0, "RESERVED_24_EXT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::RESERVED_14_EXT.0, "RESERVED_14_EXT"), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), ]; display_flags(f, KNOWN, self.0) } @@ -57785,6 +58393,37 @@ impl fmt::Display for ComponentSwizzle { } } } +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57802,12 +58441,12 @@ impl fmt::Display for PhysicalDeviceType { } } } -impl fmt::Display for PipelineBindPoint { +impl fmt::Display for BlendOverlapEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), _ => None, }; if let Some(x) = name { @@ -57817,19 +58456,12 @@ impl fmt::Display for PipelineBindPoint { } } } -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TimeDomainEXT { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEVICE => Some("DEVICE"), - Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), - Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), - Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -57839,72 +58471,141 @@ impl fmt::Display for TimeDomainEXT { } } } -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PeerMemoryFeatureFlags { +impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ConditionalRenderingFlagsEXT { +impl fmt::Display for CoarseSampleOrderTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { +impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", ), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), +>>>>>>> Implement extension chaining ]; display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD +impl fmt::Display for FenceCreateFlags { +======= +impl fmt::Display for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57932,6 +58633,1258 @@ impl fmt::Display for DynamicState { } } } +impl fmt::Display for DriverIdKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { +>>>>>>> Implement extension chaining + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +<<<<<<< HEAD +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), +======= +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), +>>>>>>> Implement extension chaining + ]; + display_flags(f, KNOWN, self.0) + } +} +<<<<<<< HEAD +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), +======= +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), +>>>>>>> Implement extension chaining + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +<<<<<<< HEAD +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +======= +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { +>>>>>>> Implement extension chaining + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +<<<<<<< HEAD +impl fmt::Display for DebugReportFlagsEXT { +======= +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { +>>>>>>> Implement extension chaining + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +<<<<<<< HEAD +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), +======= +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), +>>>>>>> Implement extension chaining + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +<<<<<<< HEAD +impl fmt::Display for PhysicalDeviceType { +======= +impl fmt::Display for DescriptorType { +>>>>>>> Implement extension chaining + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +<<<<<<< HEAD +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), +======= +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), +>>>>>>> Implement extension chaining + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +<<<<<<< HEAD +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for TimeDomainEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), +======= +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ( + PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + PipelineStageFlags::RAY_TRACING_SHADER_NV.0, + "RAY_TRACING_SHADER_NV", + ), + ( + PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, + "ACCELERATION_STRUCTURE_BUILD_NV", + ), + (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), + (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), + (PipelineStageFlags::RESERVED_23_EXT.0, "RESERVED_23_EXT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } +>>>>>>> Implement extension chaining + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +<<<<<<< HEAD +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ +======= +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), + (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), + (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), + (ShaderStageFlags::MISS_NV.0, "MISS_NV"), + (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), + (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), + (ShaderStageFlags::TASK_NV.0, "TASK_NV"), + (ShaderStageFlags::MESH_NV.0, "MESH_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ +>>>>>>> Implement extension chaining + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +<<<<<<< HEAD +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), +======= +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), +>>>>>>> Implement extension chaining + ]; + display_flags(f, KNOWN, self.0) + } +} +<<<<<<< HEAD +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", +======= +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", +>>>>>>> Implement extension chaining + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +<<<<<<< HEAD impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57979,6 +59932,45 @@ impl fmt::Display for IndexType { Self::UINT16 => Some("UINT16"), Self::UINT32 => Some("UINT32"), Self::NONE_NV => Some("NONE_NV"), +======= +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RayTracingShaderGroupTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -57988,6 +59980,7 @@ impl fmt::Display for IndexType { } } } +<<<<<<< HEAD impl fmt::Display for ValidationFeatureEnableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58044,10 +60037,35 @@ impl fmt::Display for BuildAccelerationStructureFlagsNV { BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, "LOW_MEMORY", ), +======= +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ( + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + (ImageUsageFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"), +>>>>>>> Implement extension chaining ]; display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58076,6 +60094,15 @@ impl fmt::Display for VertexInputRate { let name = match *self { Self::VERTEX => Some("VERTEX"), Self::INSTANCE => Some("INSTANCE"), +======= +impl fmt::Display for TimeDomainEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -58085,6 +60112,7 @@ impl fmt::Display for VertexInputRate { } } } +<<<<<<< HEAD impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58108,6 +60136,8 @@ impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { display_flags(f, KNOWN, self.0) } } +======= +>>>>>>> Implement extension chaining impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58115,6 +60145,7 @@ impl fmt::Display for SparseImageFormatFlags { ( SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, "ALIGNED_MIP_SIZE", +<<<<<<< HEAD ), ( SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, @@ -58150,6 +60181,12 @@ impl fmt::Display for ImageCreateFlags { ( ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, "BLOCK_TEXEL_VIEW_COMPATIBLE", +======= + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", +>>>>>>> Implement extension chaining ), (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), (ImageCreateFlags::PROTECTED.0, "PROTECTED"), @@ -58158,6 +60195,7 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD impl fmt::Display for SampleCountFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58184,6 +60222,19 @@ impl fmt::Display for QueryType { Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") } +======= +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -58193,6 +60244,7 @@ impl fmt::Display for QueryType { } } } +<<<<<<< HEAD impl fmt::Display for FormatFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; @@ -58257,6 +60309,16 @@ impl fmt::Display for DeviceEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), +======= +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -58286,12 +60348,21 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } +<<<<<<< HEAD impl fmt::Display for AttachmentLoadOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::LOAD => Some("LOAD"), Self::CLEAR => Some("CLEAR"), Self::DONT_CARE => Some("DONT_CARE"), +======= +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -58301,6 +60372,7 @@ impl fmt::Display for AttachmentLoadOp { } } } +<<<<<<< HEAD impl fmt::Display for CommandPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58310,15 +60382,38 @@ impl fmt::Display for CommandPoolCreateFlags { "RESET_COMMAND_BUFFER", ), (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), +======= +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), +>>>>>>> Implement extension chaining ]; display_flags(f, KNOWN, self.0) } } +<<<<<<< HEAD impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::ALL => Some("ALL"), Self::SHADERS => Some("SHADERS"), +======= +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -58328,6 +60423,7 @@ impl fmt::Display for ValidationCheckEXT { } } } +<<<<<<< HEAD impl fmt::Display for ExternalMemoryHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; @@ -58369,6 +60465,103 @@ impl fmt::Display for ImageViewType { Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), Self::CUBE_ARRAY => Some("CUBE_ARRAY"), +======= +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), +>>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -58393,6 +60586,7 @@ impl fmt::Display for SamplerReductionModeEXT { } } } +<<<<<<< HEAD impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58427,6 +60621,20 @@ impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", ), +======= +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), +>>>>>>> Implement extension chaining ]; display_flags(f, KNOWN, self.0) } diff --git a/examples/src/lib.rs b/examples/src/lib.rs index b2463b1..cff385b 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -341,7 +341,7 @@ impl ExampleBase { .application_version(0) .engine_name(&app_name) .engine_version(0) - .api_version(vk_make_version!(1, 0, 36)); + .api_version(vk_make_version!(1, 0, 0)); let create_info = vk::InstanceCreateInfo::builder() .application_info(&appinfo) @@ -407,14 +407,40 @@ impl ExampleBase { .queue_priorities(&priorities) .build()]; - let device_create_info = vk::DeviceCreateInfo::builder() + let mut variable_pointers = + vk::PhysicalDeviceVariablePointerFeatures::builder().variable_pointers(true); + let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder() + .corner_sampled_image(true); + let mut device_create_info = vk::DeviceCreateInfo::builder() + .next(&mut corner) + .next(&mut variable_pointers) .queue_create_infos(&queue_info) .enabled_extension_names(&device_extension_names_raw) - .enabled_features(&features); + .enabled_features(&features) + .build(); + let mut chain = + vk::ExtensionChain::from_ptr(&mut device_create_info as *mut _ as *mut _); + println!("{}", (*chain).s_type); + println!("{:?}", (*chain).p_next); + unsafe { + loop { + chain = vk::ExtensionChain::from_ptr((*chain).p_next as *mut _); + println!("{}", (*chain).s_type); + println!("{:?}", (*chain).p_next); + if (*chain).p_next.is_null() { + break; + } + } + } + use std::ops::Deref; + println!("--"); + println!("{:?}", corner.deref() as *const _); + println!("{:?}", variable_pointers.deref() as *const _); let device: Device = instance .create_device(pdevice, &device_create_info, None) .unwrap(); + let present_queue = device.get_device_queue(queue_family_index as u32, 0); let surface_formats = surface_loader diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 6a7b743..f478e42 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1595,19 +1595,14 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { } let next_function = if has_next { - if is_next_const { - quote! { - pub fn next(mut self, next: &'a T) -> #name_builder<'a> where T: #extends_name { - self.inner.p_next = next as *const T as *const c_void; - self - } - } - } else { - quote! { - pub fn next(mut self, next: &'a mut T) -> #name_builder<'a> where T: #extends_name { - self.inner.p_next = next as *mut T as *mut c_void; - self + quote! { + pub fn next(mut self, next: &'a mut impl ::std::ops::DerefMut) -> #name_builder<'a> { + unsafe{ + let ptr = &mut self.inner as *mut _ as *mut c_void; + let last_extension = ExtensionChain::last_chain(ptr); + (*last_extension).p_next = next.deref_mut() as *mut T as *mut c_void; } + self } } } else { @@ -1639,6 +1634,7 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { #next_trait + #(#nexts)* impl<'a> ::std::ops::Deref for #name_builder<'a> { @@ -1648,6 +1644,11 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { &self.inner } } + impl<'a> ::std::ops::DerefMut for #name_builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } + } impl<'a> #name_builder<'a> { #(#setters)* @@ -2145,6 +2146,32 @@ pub fn write_source_code(path: &Path) { use std::fmt; use std::os::raw::*; + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct ExtensionChain { + pub s_type: StructureType, + pub p_next: *mut c_void + } + + impl ExtensionChain { + pub unsafe fn from_ptr(ptr: *mut c_void) -> *mut Self { + ::std::mem::transmute(ptr) + } + pub unsafe fn last_chain(ptr: *mut c_void) -> *mut Self { + assert!(!ptr.is_null()); + let mut extension = ExtensionChain::from_ptr(ptr); + while !(*extension).p_next.is_null() { + extension = ExtensionChain::from_ptr((*extension).p_next); + } + extension + } + } + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct ExtensionChainMut { + pub s_type: StructureType, + pub p_next: *mut c_void + } pub trait Handle { const TYPE: ObjectType; fn as_raw(self) -> u64; From c46a41e1d23700df79a7bf2649a9e1b84f46c6b6 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 23 Feb 2019 11:08:27 +0100 Subject: [PATCH 03/21] Replace `ExtensionChain` with a simple iterator --- examples/src/lib.rs | 25 ++++++---------------- generator/src/lib.rs | 50 +++++++++++++++++++------------------------- 2 files changed, 27 insertions(+), 48 deletions(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index cff385b..01747a4 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -4,7 +4,6 @@ extern crate ash; extern crate winapi; extern crate winit; - #[cfg(target_os = "macos")] extern crate cocoa; #[cfg(target_os = "macos")] @@ -408,9 +407,9 @@ impl ExampleBase { .build()]; let mut variable_pointers = - vk::PhysicalDeviceVariablePointerFeatures::builder().variable_pointers(true); + vk::PhysicalDeviceVariablePointerFeatures::builder().variable_pointers(true).build(); let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder() - .corner_sampled_image(true); + .corner_sampled_image(true).build(); let mut device_create_info = vk::DeviceCreateInfo::builder() .next(&mut corner) .next(&mut variable_pointers) @@ -419,24 +418,12 @@ impl ExampleBase { .enabled_features(&features) .build(); - let mut chain = - vk::ExtensionChain::from_ptr(&mut device_create_info as *mut _ as *mut _); - println!("{}", (*chain).s_type); - println!("{:?}", (*chain).p_next); - unsafe { - loop { - chain = vk::ExtensionChain::from_ptr((*chain).p_next as *mut _); - println!("{}", (*chain).s_type); - println!("{:?}", (*chain).p_next); - if (*chain).p_next.is_null() { - break; - } - } + for ptr in vk::ptr_chain_iter(&mut device_create_info){ + println!("{:?}", ptr); } - use std::ops::Deref; println!("--"); - println!("{:?}", corner.deref() as *const _); - println!("{:?}", variable_pointers.deref() as *const _); + println!("{:?}", &corner as *const _); + println!("{:?}", &variable_pointers as *const _); let device: Device = instance .create_device(pdevice, &device_create_info, None) .unwrap(); diff --git a/generator/src/lib.rs b/generator/src/lib.rs index f478e42..878f586 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1596,11 +1596,13 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { let next_function = if has_next { quote! { - pub fn next(mut self, next: &'a mut impl ::std::ops::DerefMut) -> #name_builder<'a> { + pub fn next(mut self, next: &'a mut T) -> #name_builder<'a> { unsafe{ - let ptr = &mut self.inner as *mut _ as *mut c_void; - let last_extension = ExtensionChain::last_chain(ptr); - (*last_extension).p_next = next.deref_mut() as *mut T as *mut c_void; + let last_extension = ptr_chain_iter(&mut self.inner) + .last() + .expect("Initial ptr was null"); + // Append the extension at the end + (*last_extension).p_next = next as *mut T as *mut _; } self } @@ -2145,33 +2147,23 @@ pub fn write_source_code(path: &Path) { let source_code = quote! { use std::fmt; use std::os::raw::*; - - #[repr(C)] - #[derive(Debug, Copy, Clone)] - pub struct ExtensionChain { - pub s_type: StructureType, - pub p_next: *mut c_void - } - - impl ExtensionChain { - pub unsafe fn from_ptr(ptr: *mut c_void) -> *mut Self { - ::std::mem::transmute(ptr) - } - pub unsafe fn last_chain(ptr: *mut c_void) -> *mut Self { - assert!(!ptr.is_null()); - let mut extension = ExtensionChain::from_ptr(ptr); - while !(*extension).p_next.is_null() { - extension = ExtensionChain::from_ptr((*extension).p_next); + /// `T` has to be a valid xxx_create_info struct. Addtionally all the pointer chains in + /// this iterator are mutable. Make sure that all the objects in this pointer chain have an + /// active `&mut` borrow if you want to update those objects. + pub unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { + use std::ptr::null_mut; + let ptr: *mut BaseOutStructure = ::std::mem::transmute(ptr); + (0..).scan(ptr, |p_ptr, _|{ + if *p_ptr == null_mut() { + return None; } - extension - } - } - #[repr(C)] - #[derive(Debug, Copy, Clone)] - pub struct ExtensionChainMut { - pub s_type: StructureType, - pub p_next: *mut c_void + let n_ptr = (**p_ptr).p_next as *mut BaseOutStructure; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) } + pub trait Handle { const TYPE: ObjectType; fn as_raw(self) -> u64; From 4f7ca180f6f90a2f16338d3cfe01a76a44cf5659 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Tue, 26 Feb 2019 20:54:48 +0100 Subject: [PATCH 04/21] Implement `push_next` --- ash/src/extensions/nv/ray_tracing.rs | 9 ++- examples/src/lib.rs | 16 +++-- generator/src/lib.rs | 102 +++++++++++++++++++-------- 3 files changed, 84 insertions(+), 43 deletions(-) diff --git a/ash/src/extensions/nv/ray_tracing.rs b/ash/src/extensions/nv/ray_tracing.rs index fc0deca..1cde467 100644 --- a/ash/src/extensions/nv/ray_tracing.rs +++ b/ash/src/extensions/nv/ray_tracing.rs @@ -28,11 +28,10 @@ impl RayTracing { pdevice: vk::PhysicalDevice, ) -> vk::PhysicalDeviceRayTracingPropertiesNV { let mut props_rt = vk::PhysicalDeviceRayTracingPropertiesNV::default(); - let mut props = vk::PhysicalDeviceProperties2::builder() - .next(&mut props_rt) - .build(); - - instance.get_physical_device_properties2(pdevice, &mut props); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } props_rt } diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 01747a4..65b2f3b 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -3,13 +3,13 @@ extern crate ash; #[cfg(target_os = "windows")] extern crate winapi; -extern crate winit; #[cfg(target_os = "macos")] extern crate cocoa; #[cfg(target_os = "macos")] extern crate metal_rs as metal; #[cfg(target_os = "macos")] extern crate objc; +extern crate winit; #[cfg(target_os = "macos")] use cocoa::appkit::{NSView, NSWindow}; #[cfg(target_os = "macos")] @@ -406,19 +406,21 @@ impl ExampleBase { .queue_priorities(&priorities) .build()]; - let mut variable_pointers = - vk::PhysicalDeviceVariablePointerFeatures::builder().variable_pointers(true).build(); + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder() + .variable_pointers(true) + .build(); let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder() - .corner_sampled_image(true).build(); + .corner_sampled_image(true) + .build(); let mut device_create_info = vk::DeviceCreateInfo::builder() - .next(&mut corner) - .next(&mut variable_pointers) + .push_next(&mut corner) + .push_next(&mut variable_pointers) .queue_create_infos(&queue_info) .enabled_extension_names(&device_extension_names_raw) .enabled_features(&features) .build(); - for ptr in vk::ptr_chain_iter(&mut device_create_info){ + for ptr in vk::ptr_chain_iter(&mut device_create_info) { println!("{:?}", ptr); } println!("--"); diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 878f586..f4b626a 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1378,7 +1378,10 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt Some(q) } -pub fn derive_setters(_struct: &vkxml::Struct) -> Option { +pub fn derive_setters( + _struct: &vkxml::Struct, + root_create_info_names: &HashSet, +) -> Option { if &_struct.name == "VkBaseInStructure" || &_struct.name == "VkBaseOutStructure" { return None; } @@ -1578,31 +1581,26 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { }) }); - let mut nexts = Vec::new(); let extends_name = name_to_tokens(&format!("Extends{}", name)); - if let Some(extends) = &_struct.extends { - for target in extends.split(',') { - let target = match target { - // https://github.com/KhronosGroup/Vulkan-Docs/pull/870 - "VkPhysicalDeviceProperties" => "VkPhysicalDeviceProperties2", - x => x, - }; - let target_ident = name_to_tokens(&format!("Extends{}", name_to_tokens(target))); - nexts.push(quote! { - unsafe impl #target_ident for #name {} - }); - } - } - let next_function = if has_next { + let next_extends = _struct.extends.as_ref().map(|extends| { + let extends = extends + .split(',') + .find(|extend| root_create_info_names.contains(&extend.to_string())) + .expect("Should have a root create info"); + name_to_tokens(&format!("Extends{}", name_to_tokens(&extends))) + }); + + + // We only implement a next methods for root create infos + let next_function = if has_next && next_extends.is_none() { quote! { - pub fn next(mut self, next: &'a mut T) -> #name_builder<'a> { + /// Prepend + pub fn push_next(mut self, next: &'a mut T) -> #name_builder<'a> { unsafe{ - let last_extension = ptr_chain_iter(&mut self.inner) - .last() - .expect("Initial ptr was null"); - // Append the extension at the end - (*last_extension).p_next = next as *mut T as *mut _; + let next_ptr: *mut BaseOutStructure = ::std::mem::transmute(next); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; } self } @@ -1611,7 +1609,9 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { quote! {} }; - let next_trait = if has_next { + // Root create infos come with their own trait that structs that extends this create info will + // implement + let next_trait = if has_next && _struct.extends.is_none() { quote! { pub unsafe trait #extends_name {} } @@ -1619,6 +1619,15 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { quote! {} }; + // If the struct extends something we need to implement the root create info trait. + let impl_extend_trait = if let Some(next_extends) = next_extends { + quote! { + unsafe impl #next_extends for #name {} + } + } else { + quote! {} + }; + let q = quote! { impl #name { pub fn builder<'a>() -> #name_builder<'a> { @@ -1634,11 +1643,10 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { marker: ::std::marker::PhantomData<&'a ()>, } + #impl_extend_trait #next_trait - #(#nexts)* - impl<'a> ::std::ops::Deref for #name_builder<'a> { type Target = #name; @@ -1646,6 +1654,7 @@ pub fn derive_setters(_struct: &vkxml::Struct) -> Option { &self.inner } } + impl<'a> ::std::ops::DerefMut for #name_builder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner @@ -1676,7 +1685,11 @@ pub fn manual_derives(_struct: &vkxml::Struct) -> Tokens { _ => quote! {}, } } -pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Tokens { +pub fn generate_struct( + _struct: &vkxml::Struct, + root_create_info_names: &HashSet, + union_types: &HashSet<&str>, +) -> Tokens { let name = name_to_tokens(&_struct.name); let members = _struct.elements.iter().filter_map(|elem| match *elem { vkxml::StructElement::Member(ref field) => Some(field), @@ -1691,7 +1704,7 @@ pub fn generate_struct(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> let debug_tokens = derive_debug(_struct, union_types); let default_tokens = derive_default(_struct); - let setter_tokens = derive_setters(_struct); + let setter_tokens = derive_setters(_struct, root_create_info_names); let manual_derive_tokens = manual_derives(_struct); let dbg_str = if debug_tokens.is_none() { quote!(Debug,) @@ -1777,16 +1790,35 @@ fn generate_union(union: &vkxml::Union) -> Tokens { } } } +pub fn root_create_info_names(definitions: &[&vkxml::DefinitionsElement]) -> HashSet { + definitions + .iter() + .filter_map(|definition| match *definition { + vkxml::DefinitionsElement::Struct(ref _struct) => { + let is_root_create_info = _struct.extends.is_none(); + if is_root_create_info { + Some(_struct.name.clone()) + } else { + None + } + } + _ => None, + }) + .collect() +} pub fn generate_definition( definition: &vkxml::DefinitionsElement, union_types: &HashSet<&str>, + root_create_info_names: &HashSet, bitflags_cache: &mut HashSet, ) -> Option { match *definition { vkxml::DefinitionsElement::Typedef(ref typedef) => Some(generate_typedef(typedef)), - vkxml::DefinitionsElement::Struct(ref _struct) => { - Some(generate_struct(_struct, union_types)) - } + vkxml::DefinitionsElement::Struct(ref _struct) => Some(generate_struct( + _struct, + root_create_info_names, + union_types, + )), vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask, bitflags_cache), vkxml::DefinitionsElement::Handle(ref handle) => generate_handle(handle), vkxml::DefinitionsElement::FuncPtr(ref fp) => Some(generate_funcptr(fp)), @@ -2124,9 +2156,17 @@ pub fn write_source_code(path: &Path) { }) .collect::>(); + let root_create_info_names = root_create_info_names(&definitions); let definition_code: Vec<_> = definitions .into_iter() - .filter_map(|def| generate_definition(def, &union_types, &mut bitflags_cache)) + .filter_map(|def| { + generate_definition( + def, + &union_types, + &root_create_info_names, + &mut bitflags_cache, + ) + }) .collect(); let feature_code: Vec<_> = features From 3de2ca9a2213950b562c1b8cf3b398f822a7c90a Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 27 Feb 2019 11:04:31 +0100 Subject: [PATCH 05/21] Implement `ExtendsXXX` for all builders as well --- examples/src/lib.rs | 3 +-- generator/src/lib.rs | 20 +++++++++++++++----- 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 65b2f3b..75fef77 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -410,8 +410,7 @@ impl ExampleBase { .variable_pointers(true) .build(); let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder() - .corner_sampled_image(true) - .build(); + .corner_sampled_image(true); let mut device_create_info = vk::DeviceCreateInfo::builder() .push_next(&mut corner) .push_next(&mut variable_pointers) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index f4b626a..b56291a 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1591,14 +1591,13 @@ pub fn derive_setters( name_to_tokens(&format!("Extends{}", name_to_tokens(&extends))) }); - // We only implement a next methods for root create infos let next_function = if has_next && next_extends.is_none() { quote! { /// Prepend - pub fn push_next(mut self, next: &'a mut T) -> #name_builder<'a> { + pub fn push_next(mut self, next: &mut T) -> #name_builder<'a> { unsafe{ - let next_ptr: *mut BaseOutStructure = ::std::mem::transmute(next); + let next_ptr = next.as_ptr_mut(); (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -1613,7 +1612,9 @@ pub fn derive_setters( // implement let next_trait = if has_next && _struct.extends.is_none() { quote! { - pub unsafe trait #extends_name {} + pub unsafe trait #extends_name { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; + } } } else { quote! {} @@ -1622,7 +1623,16 @@ pub fn derive_setters( // If the struct extends something we need to implement the root create info trait. let impl_extend_trait = if let Some(next_extends) = next_extends { quote! { - unsafe impl #next_extends for #name {} + unsafe impl #next_extends for #name_builder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure{ + ::std::mem::transmute(&mut self.inner) + } + } + unsafe impl #next_extends for #name { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure{ + ::std::mem::transmute(self) + } + } } } else { quote! {} From c66ae6b77e6303400ad539750973b0851aae499c Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 27 Feb 2019 11:05:33 +0100 Subject: [PATCH 06/21] Add lifetime to push_next --- generator/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index b56291a..2875c95 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1595,7 +1595,7 @@ pub fn derive_setters( let next_function = if has_next && next_extends.is_none() { quote! { /// Prepend - pub fn push_next(mut self, next: &mut T) -> #name_builder<'a> { + pub fn push_next(mut self, next: &'a mut T) -> #name_builder<'a> { unsafe{ let next_ptr = next.as_ptr_mut(); (*next_ptr).p_next = self.inner.p_next as _; From 1e13b999d7be2456bd63852ca84c9ec2d697742a Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Wed, 27 Feb 2019 11:10:38 +0100 Subject: [PATCH 07/21] Add some documentation to `push_next` --- ash/src/vk.rs | 14906 ++++++++++++++++++++++------------------- generator/src/lib.rs | 6 +- 2 files changed, 7862 insertions(+), 7050 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 70af505..d858dea 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,5 +1,21 @@ use std::fmt; use std::os::raw::*; +#[doc = r" `T` has to be a valid xxx_create_info struct. Addtionally all the pointer chains in"] +#[doc = r" this iterator are mutable. Make sure that all the objects in this pointer chain have an"] +#[doc = r" active `&mut` borrow if you want to update those objects."] +pub unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { + use std::ptr::null_mut; + let ptr: *mut BaseOutStructure = ::std::mem::transmute(ptr); + (0..).scan(ptr, |p_ptr, _| { + if *p_ptr == null_mut() { + return None; + } + let n_ptr = (**p_ptr).p_next as *mut BaseOutStructure; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) +} pub trait Handle { const TYPE: ObjectType; fn as_raw(self) -> u64; @@ -7623,6 +7639,11 @@ impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Offset2DBuilder<'a> { pub fn x(mut self, x: i32) -> Offset2DBuilder<'a> { self.inner.x = x; @@ -7661,6 +7682,11 @@ impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Offset3DBuilder<'a> { pub fn x(mut self, x: i32) -> Offset3DBuilder<'a> { self.inner.x = x; @@ -7702,6 +7728,11 @@ impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Extent2DBuilder<'a> { pub fn width(mut self, width: u32) -> Extent2DBuilder<'a> { self.inner.width = width; @@ -7740,6 +7771,11 @@ impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Extent3DBuilder<'a> { pub fn width(mut self, width: u32) -> Extent3DBuilder<'a> { self.inner.width = width; @@ -7785,6 +7821,11 @@ impl<'a> ::std::ops::Deref for ViewportBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ViewportBuilder<'a> { pub fn x(mut self, x: f32) -> ViewportBuilder<'a> { self.inner.x = x; @@ -7838,6 +7879,11 @@ impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Rect2DBuilder<'a> { pub fn offset(mut self, offset: Offset2D) -> Rect2DBuilder<'a> { self.inner.offset = offset; @@ -7876,6 +7922,11 @@ impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ClearRectBuilder<'a> { pub fn rect(mut self, rect: Rect2D) -> ClearRectBuilder<'a> { self.inner.rect = rect; @@ -7919,6 +7970,11 @@ impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ComponentMappingBuilder<'a> { pub fn r(mut self, r: ComponentSwizzle) -> ComponentMappingBuilder<'a> { self.inner.r = r; @@ -8003,6 +8059,11 @@ impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDevicePropertiesBuilder<'a> { pub fn api_version(mut self, api_version: u32) -> PhysicalDevicePropertiesBuilder<'a> { self.inner.api_version = api_version; @@ -8098,6 +8159,11 @@ impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExtensionPropertiesBuilder<'a> { pub fn extension_name( mut self, @@ -8164,6 +8230,11 @@ impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> LayerPropertiesBuilder<'a> { pub fn layer_name( mut self, @@ -8230,13 +8301,20 @@ pub struct ApplicationInfoBuilder<'a> { inner: ApplicationInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsApplicationInfo {} +pub unsafe trait ExtendsApplicationInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> { type Target = ApplicationInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ApplicationInfoBuilder<'a> { pub fn application_name( mut self, @@ -8261,11 +8339,20 @@ impl<'a> ApplicationInfoBuilder<'a> { self.inner.api_version = api_version; self } - pub fn next(mut self, next: &'a T) -> ApplicationInfoBuilder<'a> - where - T: ExtendsApplicationInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ApplicationInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ApplicationInfo { @@ -8336,6 +8423,11 @@ impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AllocationCallbacksBuilder<'a> { pub fn user_data(mut self, user_data: *mut c_void) -> AllocationCallbacksBuilder<'a> { self.inner.p_user_data = user_data; @@ -8411,13 +8503,20 @@ pub struct DeviceQueueCreateInfoBuilder<'a> { inner: DeviceQueueCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceQueueCreateInfo {} +pub unsafe trait ExtendsDeviceQueueCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> { type Target = DeviceQueueCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceQueueCreateInfoBuilder<'a> { pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -8438,11 +8537,20 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> { self.inner.p_queue_priorities = queue_priorities.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DeviceQueueCreateInfoBuilder<'a> - where - T: ExtendsDeviceQueueCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DeviceQueueCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DeviceQueueCreateInfo { @@ -8491,13 +8599,20 @@ pub struct DeviceCreateInfoBuilder<'a> { inner: DeviceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceCreateInfo {} +pub unsafe trait ExtendsDeviceCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> { type Target = DeviceCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceCreateInfoBuilder<'a> { pub fn flags(mut self, flags: DeviceCreateFlags) -> DeviceCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -8534,11 +8649,20 @@ impl<'a> DeviceCreateInfoBuilder<'a> { self.inner.p_enabled_features = enabled_features; self } - pub fn next(mut self, next: &'a T) -> DeviceCreateInfoBuilder<'a> - where - T: ExtendsDeviceCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DeviceCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DeviceCreateInfo { @@ -8583,13 +8707,20 @@ pub struct InstanceCreateInfoBuilder<'a> { inner: InstanceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsInstanceCreateInfo {} +pub unsafe trait ExtendsInstanceCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> { type Target = InstanceCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> InstanceCreateInfoBuilder<'a> { pub fn flags(mut self, flags: InstanceCreateFlags) -> InstanceCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -8618,11 +8749,20 @@ impl<'a> InstanceCreateInfoBuilder<'a> { self.inner.enabled_extension_count = enabled_extension_names.len() as _; self } - pub fn next(mut self, next: &'a T) -> InstanceCreateInfoBuilder<'a> - where - T: ExtendsInstanceCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> InstanceCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> InstanceCreateInfo { @@ -8655,6 +8795,11 @@ impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> QueueFamilyPropertiesBuilder<'a> { pub fn queue_flags(mut self, queue_flags: QueueFlags) -> QueueFamilyPropertiesBuilder<'a> { self.inner.queue_flags = queue_flags; @@ -8718,6 +8863,11 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> { pub fn memory_type_count( mut self, @@ -8781,13 +8931,20 @@ pub struct MemoryAllocateInfoBuilder<'a> { inner: MemoryAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryAllocateInfo {} +pub unsafe trait ExtendsMemoryAllocateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> { type Target = MemoryAllocateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryAllocateInfoBuilder<'a> { pub fn allocation_size(mut self, allocation_size: DeviceSize) -> MemoryAllocateInfoBuilder<'a> { self.inner.allocation_size = allocation_size; @@ -8797,11 +8954,20 @@ impl<'a> MemoryAllocateInfoBuilder<'a> { self.inner.memory_type_index = memory_type_index; self } - pub fn next(mut self, next: &'a T) -> MemoryAllocateInfoBuilder<'a> - where - T: ExtendsMemoryAllocateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryAllocateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryAllocateInfo { @@ -8833,6 +8999,11 @@ impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryRequirementsBuilder<'a> { pub fn size(mut self, size: DeviceSize) -> MemoryRequirementsBuilder<'a> { self.inner.size = size; @@ -8875,6 +9046,11 @@ impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseImageFormatPropertiesBuilder<'a> { pub fn aspect_mask( mut self, @@ -8928,6 +9104,11 @@ impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseImageMemoryRequirementsBuilder<'a> { pub fn format_properties( mut self, @@ -8992,6 +9173,11 @@ impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryTypeBuilder<'a> { pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> MemoryTypeBuilder<'a> { self.inner.property_flags = property_flags; @@ -9029,6 +9215,11 @@ impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryHeapBuilder<'a> { pub fn size(mut self, size: DeviceSize) -> MemoryHeapBuilder<'a> { self.inner.size = size; @@ -9074,13 +9265,20 @@ pub struct MappedMemoryRangeBuilder<'a> { inner: MappedMemoryRange, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMappedMemoryRange {} +pub unsafe trait ExtendsMappedMemoryRange { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> { type Target = MappedMemoryRange; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MappedMemoryRangeBuilder<'a> { pub fn memory(mut self, memory: DeviceMemory) -> MappedMemoryRangeBuilder<'a> { self.inner.memory = memory; @@ -9094,11 +9292,20 @@ impl<'a> MappedMemoryRangeBuilder<'a> { self.inner.size = size; self } - pub fn next(mut self, next: &'a T) -> MappedMemoryRangeBuilder<'a> - where - T: ExtendsMappedMemoryRange, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MappedMemoryRangeBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MappedMemoryRange { @@ -9130,6 +9337,11 @@ impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> FormatPropertiesBuilder<'a> { pub fn linear_tiling_features( mut self, @@ -9183,6 +9395,11 @@ impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageFormatPropertiesBuilder<'a> { pub fn max_extent(mut self, max_extent: Extent3D) -> ImageFormatPropertiesBuilder<'a> { self.inner.max_extent = max_extent; @@ -9239,6 +9456,11 @@ impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorBufferInfoBuilder<'a> { pub fn buffer(mut self, buffer: Buffer) -> DescriptorBufferInfoBuilder<'a> { self.inner.buffer = buffer; @@ -9281,6 +9503,11 @@ impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorImageInfoBuilder<'a> { pub fn sampler(mut self, sampler: Sampler) -> DescriptorImageInfoBuilder<'a> { self.inner.sampler = sampler; @@ -9340,13 +9567,20 @@ pub struct WriteDescriptorSetBuilder<'a> { inner: WriteDescriptorSet, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWriteDescriptorSet {} +pub unsafe trait ExtendsWriteDescriptorSet { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> { type Target = WriteDescriptorSet; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> WriteDescriptorSetBuilder<'a> { pub fn dst_set(mut self, dst_set: DescriptorSet) -> WriteDescriptorSetBuilder<'a> { self.inner.dst_set = dst_set; @@ -9391,11 +9625,20 @@ impl<'a> WriteDescriptorSetBuilder<'a> { self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> WriteDescriptorSetBuilder<'a> - where - T: ExtendsWriteDescriptorSet, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> WriteDescriptorSetBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> WriteDescriptorSet { @@ -9442,13 +9685,20 @@ pub struct CopyDescriptorSetBuilder<'a> { inner: CopyDescriptorSet, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyDescriptorSet {} +pub unsafe trait ExtendsCopyDescriptorSet { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> { type Target = CopyDescriptorSet; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CopyDescriptorSetBuilder<'a> { pub fn src_set(mut self, src_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a> { self.inner.src_set = src_set; @@ -9478,11 +9728,20 @@ impl<'a> CopyDescriptorSetBuilder<'a> { self.inner.descriptor_count = descriptor_count; self } - pub fn next(mut self, next: &'a T) -> CopyDescriptorSetBuilder<'a> - where - T: ExtendsCopyDescriptorSet, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CopyDescriptorSetBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CopyDescriptorSet { @@ -9527,13 +9786,20 @@ pub struct BufferCreateInfoBuilder<'a> { inner: BufferCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferCreateInfo {} +pub unsafe trait ExtendsBufferCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> { type Target = BufferCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferCreateInfoBuilder<'a> { pub fn flags(mut self, flags: BufferCreateFlags) -> BufferCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -9559,11 +9825,20 @@ impl<'a> BufferCreateInfoBuilder<'a> { self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> BufferCreateInfoBuilder<'a> - where - T: ExtendsBufferCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BufferCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BufferCreateInfo { @@ -9606,13 +9881,20 @@ pub struct BufferViewCreateInfoBuilder<'a> { inner: BufferViewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferViewCreateInfo {} +pub unsafe trait ExtendsBufferViewCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { type Target = BufferViewCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferViewCreateInfoBuilder<'a> { pub fn flags(mut self, flags: BufferViewCreateFlags) -> BufferViewCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -9634,11 +9916,20 @@ impl<'a> BufferViewCreateInfoBuilder<'a> { self.inner.range = range; self } - pub fn next(mut self, next: &'a T) -> BufferViewCreateInfoBuilder<'a> - where - T: ExtendsBufferViewCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BufferViewCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BufferViewCreateInfo { @@ -9670,6 +9961,11 @@ impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageSubresourceBuilder<'a> { pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ImageSubresourceBuilder<'a> { self.inner.aspect_mask = aspect_mask; @@ -9713,6 +10009,11 @@ impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageSubresourceLayersBuilder<'a> { pub fn aspect_mask( mut self, @@ -9764,6 +10065,11 @@ impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageSubresourceRangeBuilder<'a> { pub fn aspect_mask( mut self, @@ -9822,13 +10128,20 @@ pub struct MemoryBarrierBuilder<'a> { inner: MemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryBarrier {} +pub unsafe trait ExtendsMemoryBarrier { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> { type Target = MemoryBarrier; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryBarrierBuilder<'a> { pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a> { self.inner.src_access_mask = src_access_mask; @@ -9838,11 +10151,20 @@ impl<'a> MemoryBarrierBuilder<'a> { self.inner.dst_access_mask = dst_access_mask; self } - pub fn next(mut self, next: &'a T) -> MemoryBarrierBuilder<'a> - where - T: ExtendsMemoryBarrier, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryBarrierBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryBarrier { @@ -9889,13 +10211,20 @@ pub struct BufferMemoryBarrierBuilder<'a> { inner: BufferMemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferMemoryBarrier {} +pub unsafe trait ExtendsBufferMemoryBarrier { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> { type Target = BufferMemoryBarrier; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferMemoryBarrierBuilder<'a> { pub fn src_access_mask( mut self, @@ -9937,11 +10266,20 @@ impl<'a> BufferMemoryBarrierBuilder<'a> { self.inner.size = size; self } - pub fn next(mut self, next: &'a T) -> BufferMemoryBarrierBuilder<'a> - where - T: ExtendsBufferMemoryBarrier, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BufferMemoryBarrierBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BufferMemoryBarrier { @@ -9990,13 +10328,20 @@ pub struct ImageMemoryBarrierBuilder<'a> { inner: ImageMemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageMemoryBarrier {} +pub unsafe trait ExtendsImageMemoryBarrier { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> { type Target = ImageMemoryBarrier; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageMemoryBarrierBuilder<'a> { pub fn src_access_mask( mut self, @@ -10045,11 +10390,20 @@ impl<'a> ImageMemoryBarrierBuilder<'a> { self.inner.subresource_range = subresource_range; self } - pub fn next(mut self, next: &'a T) -> ImageMemoryBarrierBuilder<'a> - where - T: ExtendsImageMemoryBarrier, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImageMemoryBarrierBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImageMemoryBarrier { @@ -10108,13 +10462,20 @@ pub struct ImageCreateInfoBuilder<'a> { inner: ImageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageCreateInfo {} +pub unsafe trait ExtendsImageCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> { type Target = ImageCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageCreateInfoBuilder<'a> { pub fn flags(mut self, flags: ImageCreateFlags) -> ImageCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -10168,11 +10529,20 @@ impl<'a> ImageCreateInfoBuilder<'a> { self.inner.initial_layout = initial_layout; self } - pub fn next(mut self, next: &'a T) -> ImageCreateInfoBuilder<'a> - where - T: ExtendsImageCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImageCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImageCreateInfo { @@ -10206,6 +10576,11 @@ impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubresourceLayoutBuilder<'a> { pub fn offset(mut self, offset: DeviceSize) -> SubresourceLayoutBuilder<'a> { self.inner.offset = offset; @@ -10269,13 +10644,20 @@ pub struct ImageViewCreateInfoBuilder<'a> { inner: ImageViewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageViewCreateInfo {} +pub unsafe trait ExtendsImageViewCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> { type Target = ImageViewCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageViewCreateInfoBuilder<'a> { pub fn flags(mut self, flags: ImageViewCreateFlags) -> ImageViewCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -10304,11 +10686,20 @@ impl<'a> ImageViewCreateInfoBuilder<'a> { self.inner.subresource_range = subresource_range; self } - pub fn next(mut self, next: &'a T) -> ImageViewCreateInfoBuilder<'a> - where - T: ExtendsImageViewCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImageViewCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImageViewCreateInfo { @@ -10340,6 +10731,11 @@ impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferCopyBuilder<'a> { pub fn src_offset(mut self, src_offset: DeviceSize) -> BufferCopyBuilder<'a> { self.inner.src_offset = src_offset; @@ -10384,6 +10780,11 @@ impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseMemoryBindBuilder<'a> { pub fn resource_offset(mut self, resource_offset: DeviceSize) -> SparseMemoryBindBuilder<'a> { self.inner.resource_offset = resource_offset; @@ -10437,6 +10838,11 @@ impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseImageMemoryBindBuilder<'a> { pub fn subresource( mut self, @@ -10503,6 +10909,11 @@ impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseBufferMemoryBindInfoBuilder<'a> { pub fn buffer(mut self, buffer: Buffer) -> SparseBufferMemoryBindInfoBuilder<'a> { self.inner.buffer = buffer; @@ -10551,6 +10962,11 @@ impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> { pub fn image(mut self, image: Image) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { self.inner.image = image; @@ -10602,6 +11018,11 @@ impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseImageMemoryBindInfoBuilder<'a> { pub fn image(mut self, image: Image) -> SparseImageMemoryBindInfoBuilder<'a> { self.inner.image = image; @@ -10665,13 +11086,20 @@ pub struct BindSparseInfoBuilder<'a> { inner: BindSparseInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindSparseInfo {} +pub unsafe trait ExtendsBindSparseInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> { type Target = BindSparseInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindSparseInfoBuilder<'a> { pub fn wait_semaphores( mut self, @@ -10713,11 +11141,20 @@ impl<'a> BindSparseInfoBuilder<'a> { self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> BindSparseInfoBuilder<'a> - where - T: ExtendsBindSparseInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BindSparseInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BindSparseInfo { @@ -10751,6 +11188,11 @@ impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageCopyBuilder<'a> { pub fn src_subresource( mut self, @@ -10818,6 +11260,11 @@ impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageBlitBuilder<'a> { pub fn src_subresource( mut self, @@ -10873,6 +11320,11 @@ impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferImageCopyBuilder<'a> { pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopyBuilder<'a> { self.inner.buffer_offset = buffer_offset; @@ -10932,6 +11384,11 @@ impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageResolveBuilder<'a> { pub fn src_subresource( mut self, @@ -10995,13 +11452,20 @@ pub struct ShaderModuleCreateInfoBuilder<'a> { inner: ShaderModuleCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsShaderModuleCreateInfo {} +pub unsafe trait ExtendsShaderModuleCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> { type Target = ShaderModuleCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ShaderModuleCreateInfoBuilder<'a> { pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> ShaderModuleCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -11012,11 +11476,20 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> { self.inner.p_code = code.as_ptr() as *const u32; self } - pub fn next(mut self, next: &'a T) -> ShaderModuleCreateInfoBuilder<'a> - where - T: ExtendsShaderModuleCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ShaderModuleCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ShaderModuleCreateInfo { @@ -11061,6 +11534,11 @@ impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorSetLayoutBindingBuilder<'a> { pub fn binding(mut self, binding: u32) -> DescriptorSetLayoutBindingBuilder<'a> { self.inner.binding = binding; @@ -11131,13 +11609,20 @@ pub struct DescriptorSetLayoutCreateInfoBuilder<'a> { inner: DescriptorSetLayoutCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {} +pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> { type Target = DescriptorSetLayoutCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -11154,11 +11639,20 @@ impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { self.inner.p_bindings = bindings.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DescriptorSetLayoutCreateInfoBuilder<'a> - where - T: ExtendsDescriptorSetLayoutCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DescriptorSetLayoutCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DescriptorSetLayoutCreateInfo { @@ -11189,6 +11683,11 @@ impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorPoolSizeBuilder<'a> { pub fn ty(mut self, ty: DescriptorType) -> DescriptorPoolSizeBuilder<'a> { self.inner.ty = ty; @@ -11236,13 +11735,20 @@ pub struct DescriptorPoolCreateInfoBuilder<'a> { inner: DescriptorPoolCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorPoolCreateInfo {} +pub unsafe trait ExtendsDescriptorPoolCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> { type Target = DescriptorPoolCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorPoolCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -11263,11 +11769,20 @@ impl<'a> DescriptorPoolCreateInfoBuilder<'a> { self.inner.p_pool_sizes = pool_sizes.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DescriptorPoolCreateInfoBuilder<'a> - where - T: ExtendsDescriptorPoolCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DescriptorPoolCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DescriptorPoolCreateInfo { @@ -11306,13 +11821,20 @@ pub struct DescriptorSetAllocateInfoBuilder<'a> { inner: DescriptorSetAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetAllocateInfo {} +pub unsafe trait ExtendsDescriptorSetAllocateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> { type Target = DescriptorSetAllocateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorSetAllocateInfoBuilder<'a> { pub fn descriptor_pool( mut self, @@ -11329,11 +11851,20 @@ impl<'a> DescriptorSetAllocateInfoBuilder<'a> { self.inner.p_set_layouts = set_layouts.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DescriptorSetAllocateInfoBuilder<'a> - where - T: ExtendsDescriptorSetAllocateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DescriptorSetAllocateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DescriptorSetAllocateInfo { @@ -11365,6 +11896,11 @@ impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SpecializationMapEntryBuilder<'a> { pub fn constant_id(mut self, constant_id: u32) -> SpecializationMapEntryBuilder<'a> { self.inner.constant_id = constant_id; @@ -11418,6 +11954,11 @@ impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SpecializationInfoBuilder<'a> { pub fn map_entries( mut self, @@ -11472,13 +12013,20 @@ pub struct PipelineShaderStageCreateInfoBuilder<'a> { inner: PipelineShaderStageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineShaderStageCreateInfo {} +pub unsafe trait ExtendsPipelineShaderStageCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> { type Target = PipelineShaderStageCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -11506,11 +12054,20 @@ impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { self.inner.p_specialization_info = specialization_info; self } - pub fn next(mut self, next: &'a T) -> PipelineShaderStageCreateInfoBuilder<'a> - where - T: ExtendsPipelineShaderStageCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineShaderStageCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineShaderStageCreateInfo { @@ -11553,13 +12110,20 @@ pub struct ComputePipelineCreateInfoBuilder<'a> { inner: ComputePipelineCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsComputePipelineCreateInfo {} +pub unsafe trait ExtendsComputePipelineCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> { type Target = ComputePipelineCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ComputePipelineCreateInfoBuilder<'a> { pub fn flags(mut self, flags: PipelineCreateFlags) -> ComputePipelineCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -11590,11 +12154,20 @@ impl<'a> ComputePipelineCreateInfoBuilder<'a> { self.inner.base_pipeline_index = base_pipeline_index; self } - pub fn next(mut self, next: &'a T) -> ComputePipelineCreateInfoBuilder<'a> - where - T: ExtendsComputePipelineCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ComputePipelineCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ComputePipelineCreateInfo { @@ -11626,6 +12199,11 @@ impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> VertexInputBindingDescriptionBuilder<'a> { pub fn binding(mut self, binding: u32) -> VertexInputBindingDescriptionBuilder<'a> { self.inner.binding = binding; @@ -11672,6 +12250,11 @@ impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> VertexInputAttributeDescriptionBuilder<'a> { pub fn location(mut self, location: u32) -> VertexInputAttributeDescriptionBuilder<'a> { self.inner.location = location; @@ -11729,13 +12312,20 @@ pub struct PipelineVertexInputStateCreateInfoBuilder<'a> { inner: PipelineVertexInputStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {} +pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> { type Target = PipelineVertexInputStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -11760,11 +12350,20 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineVertexInputStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineVertexInputStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineVertexInputStateCreateInfo { @@ -11803,13 +12402,20 @@ pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> { inner: PipelineInputAssemblyStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineInputAssemblyStateCreateInfo {} +pub unsafe trait ExtendsPipelineInputAssemblyStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> { type Target = PipelineInputAssemblyStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -11832,11 +12438,20 @@ impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { self.inner.primitive_restart_enable = primitive_restart_enable.into(); self } - pub fn next(mut self, next: &'a T) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineInputAssemblyStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineInputAssemblyStateCreateInfo { @@ -11873,13 +12488,20 @@ pub struct PipelineTessellationStateCreateInfoBuilder<'a> { inner: PipelineTessellationStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {} +pub unsafe trait ExtendsPipelineTessellationStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> { type Target = PipelineTessellationStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -11895,11 +12517,20 @@ impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { self.inner.patch_control_points = patch_control_points; self } - pub fn next(mut self, next: &'a T) -> PipelineTessellationStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineTessellationStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineTessellationStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineTessellationStateCreateInfo { @@ -11942,13 +12573,20 @@ pub struct PipelineViewportStateCreateInfoBuilder<'a> { inner: PipelineViewportStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineViewportStateCreateInfo {} +pub unsafe trait ExtendsPipelineViewportStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> { type Target = PipelineViewportStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -11987,11 +12625,20 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { self.inner.p_scissors = scissors.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineViewportStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineViewportStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineViewportStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineViewportStateCreateInfo { @@ -12046,13 +12693,20 @@ pub struct PipelineRasterizationStateCreateInfoBuilder<'a> { inner: PipelineRasterizationStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {} +pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> { type Target = PipelineRasterizationStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -12131,11 +12785,20 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { self.inner.line_width = line_width; self } - pub fn next(mut self, next: &'a T) -> PipelineRasterizationStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineRasterizationStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineRasterizationStateCreateInfo { @@ -12182,13 +12845,20 @@ pub struct PipelineMultisampleStateCreateInfoBuilder<'a> { inner: PipelineMultisampleStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {} +pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> { type Target = PipelineMultisampleStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -12239,11 +12909,20 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { self.inner.alpha_to_one_enable = alpha_to_one_enable.into(); self } - pub fn next(mut self, next: &'a T) -> PipelineMultisampleStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineMultisampleStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineMultisampleStateCreateInfo { @@ -12280,6 +12959,11 @@ impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> { pub fn blend_enable( mut self, @@ -12379,13 +13063,20 @@ pub struct PipelineColorBlendStateCreateInfoBuilder<'a> { inner: PipelineColorBlendStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {} +pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> { type Target = PipelineColorBlendStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -12420,11 +13111,20 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { self.inner.blend_constants = blend_constants; self } - pub fn next(mut self, next: &'a T) -> PipelineColorBlendStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineColorBlendStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineColorBlendStateCreateInfo { @@ -12463,13 +13163,20 @@ pub struct PipelineDynamicStateCreateInfoBuilder<'a> { inner: PipelineDynamicStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineDynamicStateCreateInfo {} +pub unsafe trait ExtendsPipelineDynamicStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> { type Target = PipelineDynamicStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -12486,11 +13193,20 @@ impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { self.inner.p_dynamic_states = dynamic_states.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineDynamicStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineDynamicStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineDynamicStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineDynamicStateCreateInfo { @@ -12526,6 +13242,11 @@ impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> StencilOpStateBuilder<'a> { pub fn fail_op(mut self, fail_op: StencilOp) -> StencilOpStateBuilder<'a> { self.inner.fail_op = fail_op; @@ -12605,13 +13326,20 @@ pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> { inner: PipelineDepthStencilStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineDepthStencilStateCreateInfo {} +pub unsafe trait ExtendsPipelineDepthStencilStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> { type Target = PipelineDepthStencilStateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -12680,11 +13408,20 @@ impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { self.inner.max_depth_bounds = max_depth_bounds; self } - pub fn next(mut self, next: &'a T) -> PipelineDepthStencilStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineDepthStencilStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineDepthStencilStateCreateInfo { @@ -12751,13 +13488,20 @@ pub struct GraphicsPipelineCreateInfoBuilder<'a> { inner: GraphicsPipelineCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGraphicsPipelineCreateInfo {} +pub unsafe trait ExtendsGraphicsPipelineCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> { type Target = GraphicsPipelineCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { pub fn flags(mut self, flags: PipelineCreateFlags) -> GraphicsPipelineCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -12860,11 +13604,20 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { self.inner.base_pipeline_index = base_pipeline_index; self } - pub fn next(mut self, next: &'a T) -> GraphicsPipelineCreateInfoBuilder<'a> - where - T: ExtendsGraphicsPipelineCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> GraphicsPipelineCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> GraphicsPipelineCreateInfo { @@ -12903,13 +13656,20 @@ pub struct PipelineCacheCreateInfoBuilder<'a> { inner: PipelineCacheCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineCacheCreateInfo {} +pub unsafe trait ExtendsPipelineCacheCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> { type Target = PipelineCacheCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineCacheCreateInfoBuilder<'a> { pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> PipelineCacheCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -12920,11 +13680,20 @@ impl<'a> PipelineCacheCreateInfoBuilder<'a> { self.inner.p_initial_data = initial_data.as_ptr() as *const c_void; self } - pub fn next(mut self, next: &'a T) -> PipelineCacheCreateInfoBuilder<'a> - where - T: ExtendsPipelineCacheCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineCacheCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineCacheCreateInfo { @@ -12956,6 +13725,11 @@ impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PushConstantRangeBuilder<'a> { pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> PushConstantRangeBuilder<'a> { self.inner.stage_flags = stage_flags; @@ -13009,13 +13783,20 @@ pub struct PipelineLayoutCreateInfoBuilder<'a> { inner: PipelineLayoutCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineLayoutCreateInfo {} +pub unsafe trait ExtendsPipelineLayoutCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> { type Target = PipelineLayoutCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineLayoutCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -13040,11 +13821,20 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> { self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineLayoutCreateInfoBuilder<'a> - where - T: ExtendsPipelineLayoutCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PipelineLayoutCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PipelineLayoutCreateInfo { @@ -13109,13 +13899,20 @@ pub struct SamplerCreateInfoBuilder<'a> { inner: SamplerCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSamplerCreateInfo {} +pub unsafe trait ExtendsSamplerCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> { type Target = SamplerCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SamplerCreateInfoBuilder<'a> { pub fn flags(mut self, flags: SamplerCreateFlags) -> SamplerCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -13193,11 +13990,20 @@ impl<'a> SamplerCreateInfoBuilder<'a> { self.inner.unnormalized_coordinates = unnormalized_coordinates.into(); self } - pub fn next(mut self, next: &'a T) -> SamplerCreateInfoBuilder<'a> - where - T: ExtendsSamplerCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SamplerCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SamplerCreateInfo { @@ -13234,13 +14040,20 @@ pub struct CommandPoolCreateInfoBuilder<'a> { inner: CommandPoolCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandPoolCreateInfo {} +pub unsafe trait ExtendsCommandPoolCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> { type Target = CommandPoolCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CommandPoolCreateInfoBuilder<'a> { pub fn flags(mut self, flags: CommandPoolCreateFlags) -> CommandPoolCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -13253,11 +14066,20 @@ impl<'a> CommandPoolCreateInfoBuilder<'a> { self.inner.queue_family_index = queue_family_index; self } - pub fn next(mut self, next: &'a T) -> CommandPoolCreateInfoBuilder<'a> - where - T: ExtendsCommandPoolCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CommandPoolCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CommandPoolCreateInfo { @@ -13296,13 +14118,20 @@ pub struct CommandBufferAllocateInfoBuilder<'a> { inner: CommandBufferAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferAllocateInfo {} +pub unsafe trait ExtendsCommandBufferAllocateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> { type Target = CommandBufferAllocateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CommandBufferAllocateInfoBuilder<'a> { pub fn command_pool( mut self, @@ -13322,11 +14151,20 @@ impl<'a> CommandBufferAllocateInfoBuilder<'a> { self.inner.command_buffer_count = command_buffer_count; self } - pub fn next(mut self, next: &'a T) -> CommandBufferAllocateInfoBuilder<'a> - where - T: ExtendsCommandBufferAllocateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CommandBufferAllocateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CommandBufferAllocateInfo { @@ -13371,13 +14209,20 @@ pub struct CommandBufferInheritanceInfoBuilder<'a> { inner: CommandBufferInheritanceInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferInheritanceInfo {} +pub unsafe trait ExtendsCommandBufferInheritanceInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> { type Target = CommandBufferInheritanceInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CommandBufferInheritanceInfoBuilder<'a> { pub fn render_pass( mut self, @@ -13418,11 +14263,20 @@ impl<'a> CommandBufferInheritanceInfoBuilder<'a> { self.inner.pipeline_statistics = pipeline_statistics; self } - pub fn next(mut self, next: &'a T) -> CommandBufferInheritanceInfoBuilder<'a> - where - T: ExtendsCommandBufferInheritanceInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CommandBufferInheritanceInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CommandBufferInheritanceInfo { @@ -13459,13 +14313,20 @@ pub struct CommandBufferBeginInfoBuilder<'a> { inner: CommandBufferBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferBeginInfo {} +pub unsafe trait ExtendsCommandBufferBeginInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> { type Target = CommandBufferBeginInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CommandBufferBeginInfoBuilder<'a> { pub fn flags(mut self, flags: CommandBufferUsageFlags) -> CommandBufferBeginInfoBuilder<'a> { self.inner.flags = flags; @@ -13478,11 +14339,20 @@ impl<'a> CommandBufferBeginInfoBuilder<'a> { self.inner.p_inheritance_info = inheritance_info; self } - pub fn next(mut self, next: &'a T) -> CommandBufferBeginInfoBuilder<'a> - where - T: ExtendsCommandBufferBeginInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CommandBufferBeginInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CommandBufferBeginInfo { @@ -13538,13 +14408,20 @@ pub struct RenderPassBeginInfoBuilder<'a> { inner: RenderPassBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassBeginInfo {} +pub unsafe trait ExtendsRenderPassBeginInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> { type Target = RenderPassBeginInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RenderPassBeginInfoBuilder<'a> { pub fn render_pass(mut self, render_pass: RenderPass) -> RenderPassBeginInfoBuilder<'a> { self.inner.render_pass = render_pass; @@ -13566,11 +14443,20 @@ impl<'a> RenderPassBeginInfoBuilder<'a> { self.inner.p_clear_values = clear_values.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> RenderPassBeginInfoBuilder<'a> - where - T: ExtendsRenderPassBeginInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> RenderPassBeginInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> RenderPassBeginInfo { @@ -13613,6 +14499,11 @@ impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ClearDepthStencilValueBuilder<'a> { pub fn depth(mut self, depth: f32) -> ClearDepthStencilValueBuilder<'a> { self.inner.depth = depth; @@ -13671,6 +14562,11 @@ impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ClearAttachmentBuilder<'a> { pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ClearAttachmentBuilder<'a> { self.inner.aspect_mask = aspect_mask; @@ -13719,6 +14615,11 @@ impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AttachmentDescriptionBuilder<'a> { pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescriptionBuilder<'a> { self.inner.flags = flags; @@ -13793,6 +14694,11 @@ impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AttachmentReferenceBuilder<'a> { pub fn attachment(mut self, attachment: u32) -> AttachmentReferenceBuilder<'a> { self.inner.attachment = attachment; @@ -13854,6 +14760,11 @@ impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassDescriptionBuilder<'a> { pub fn flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescriptionBuilder<'a> { self.inner.flags = flags; @@ -13938,6 +14849,11 @@ impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassDependencyBuilder<'a> { pub fn src_subpass(mut self, src_subpass: u32) -> SubpassDependencyBuilder<'a> { self.inner.src_subpass = src_subpass; @@ -14020,13 +14936,20 @@ pub struct RenderPassCreateInfoBuilder<'a> { inner: RenderPassCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassCreateInfo {} +pub unsafe trait ExtendsRenderPassCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> { type Target = RenderPassCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RenderPassCreateInfoBuilder<'a> { pub fn flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -14056,11 +14979,20 @@ impl<'a> RenderPassCreateInfoBuilder<'a> { self.inner.p_dependencies = dependencies.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> RenderPassCreateInfoBuilder<'a> - where - T: ExtendsRenderPassCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> RenderPassCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> RenderPassCreateInfo { @@ -14095,23 +15027,39 @@ pub struct EventCreateInfoBuilder<'a> { inner: EventCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsEventCreateInfo {} +pub unsafe trait ExtendsEventCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { type Target = EventCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> EventCreateInfoBuilder<'a> { pub fn flags(mut self, flags: EventCreateFlags) -> EventCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn next(mut self, next: &'a T) -> EventCreateInfoBuilder<'a> - where - T: ExtendsEventCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> EventCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> EventCreateInfo { @@ -14146,23 +15094,39 @@ pub struct FenceCreateInfoBuilder<'a> { inner: FenceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceCreateInfo {} +pub unsafe trait ExtendsFenceCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> { type Target = FenceCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> FenceCreateInfoBuilder<'a> { pub fn flags(mut self, flags: FenceCreateFlags) -> FenceCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn next(mut self, next: &'a T) -> FenceCreateInfoBuilder<'a> - where - T: ExtendsFenceCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> FenceCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> FenceCreateInfo { @@ -14246,6 +15210,11 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceFeaturesBuilder<'a> { pub fn robust_buffer_access( mut self, @@ -14626,6 +15595,11 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> { pub fn residency_standard2_d_block_shape( mut self, @@ -14907,6 +15881,11 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceLimitsBuilder<'a> { pub fn max_image_dimension1_d( mut self, @@ -15685,23 +16664,39 @@ pub struct SemaphoreCreateInfoBuilder<'a> { inner: SemaphoreCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreCreateInfo {} +pub unsafe trait ExtendsSemaphoreCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> { type Target = SemaphoreCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SemaphoreCreateInfoBuilder<'a> { pub fn flags(mut self, flags: SemaphoreCreateFlags) -> SemaphoreCreateInfoBuilder<'a> { self.inner.flags = flags; self } - pub fn next(mut self, next: &'a T) -> SemaphoreCreateInfoBuilder<'a> - where - T: ExtendsSemaphoreCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SemaphoreCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SemaphoreCreateInfo { @@ -15742,13 +16737,20 @@ pub struct QueryPoolCreateInfoBuilder<'a> { inner: QueryPoolCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsQueryPoolCreateInfo {} +pub unsafe trait ExtendsQueryPoolCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> { type Target = QueryPoolCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> QueryPoolCreateInfoBuilder<'a> { pub fn flags(mut self, flags: QueryPoolCreateFlags) -> QueryPoolCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -15769,11 +16771,20 @@ impl<'a> QueryPoolCreateInfoBuilder<'a> { self.inner.pipeline_statistics = pipeline_statistics; self } - pub fn next(mut self, next: &'a T) -> QueryPoolCreateInfoBuilder<'a> - where - T: ExtendsQueryPoolCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> QueryPoolCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> QueryPoolCreateInfo { @@ -15820,13 +16831,20 @@ pub struct FramebufferCreateInfoBuilder<'a> { inner: FramebufferCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFramebufferCreateInfo {} +pub unsafe trait ExtendsFramebufferCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> { type Target = FramebufferCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> FramebufferCreateInfoBuilder<'a> { pub fn flags(mut self, flags: FramebufferCreateFlags) -> FramebufferCreateInfoBuilder<'a> { self.inner.flags = flags; @@ -15853,11 +16871,20 @@ impl<'a> FramebufferCreateInfoBuilder<'a> { self.inner.layers = layers; self } - pub fn next(mut self, next: &'a T) -> FramebufferCreateInfoBuilder<'a> - where - T: ExtendsFramebufferCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> FramebufferCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> FramebufferCreateInfo { @@ -15890,6 +16917,11 @@ impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DrawIndirectCommandBuilder<'a> { pub fn vertex_count(mut self, vertex_count: u32) -> DrawIndirectCommandBuilder<'a> { self.inner.vertex_count = vertex_count; @@ -15938,6 +16970,11 @@ impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DrawIndexedIndirectCommandBuilder<'a> { pub fn index_count(mut self, index_count: u32) -> DrawIndexedIndirectCommandBuilder<'a> { self.inner.index_count = index_count; @@ -15988,6 +17025,11 @@ impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DispatchIndirectCommandBuilder<'a> { pub fn x(mut self, x: u32) -> DispatchIndirectCommandBuilder<'a> { self.inner.x = x; @@ -16045,13 +17087,20 @@ pub struct SubmitInfoBuilder<'a> { inner: SubmitInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubmitInfo {} +pub unsafe trait ExtendsSubmitInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> { type Target = SubmitInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubmitInfoBuilder<'a> { pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> SubmitInfoBuilder<'a> { self.inner.wait_semaphore_count = wait_semaphores.len() as _; @@ -16082,11 +17131,17 @@ impl<'a> SubmitInfoBuilder<'a> { self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> SubmitInfoBuilder<'a> - where - T: ExtendsSubmitInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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) -> SubmitInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SubmitInfo { @@ -16135,6 +17190,11 @@ impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPropertiesKHRBuilder<'a> { pub fn display(mut self, display: DisplayKHR) -> DisplayPropertiesKHRBuilder<'a> { self.inner.display = display; @@ -16207,6 +17267,11 @@ impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPlanePropertiesKHRBuilder<'a> { pub fn current_display( mut self, @@ -16250,6 +17315,11 @@ impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayModeParametersKHRBuilder<'a> { pub fn visible_region( mut self, @@ -16290,6 +17360,11 @@ impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayModePropertiesKHRBuilder<'a> { pub fn display_mode( mut self, @@ -16339,13 +17414,20 @@ pub struct DisplayModeCreateInfoKHRBuilder<'a> { inner: DisplayModeCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayModeCreateInfoKHR {} +pub unsafe trait ExtendsDisplayModeCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> { type Target = DisplayModeCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { pub fn flags( mut self, @@ -16361,11 +17443,20 @@ impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { self.inner.parameters = parameters; self } - pub fn next(mut self, next: &'a T) -> DisplayModeCreateInfoKHRBuilder<'a> - where - T: ExtendsDisplayModeCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayModeCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayModeCreateInfoKHR { @@ -16403,6 +17494,11 @@ impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> { pub fn supported_alpha( mut self, @@ -16513,13 +17609,20 @@ pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> { inner: DisplaySurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplaySurfaceCreateInfoKHR {} +pub unsafe trait ExtendsDisplaySurfaceCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> { type Target = DisplaySurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { pub fn flags( mut self, @@ -16571,11 +17674,20 @@ impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { self.inner.image_extent = image_extent; self } - pub fn next(mut self, next: &'a T) -> DisplaySurfaceCreateInfoKHRBuilder<'a> - where - T: ExtendsDisplaySurfaceCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplaySurfaceCreateInfoKHR { @@ -16614,14 +17726,27 @@ pub struct DisplayPresentInfoKHRBuilder<'a> { inner: DisplayPresentInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPresentInfoKHR {} -unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> { type Target = DisplayPresentInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPresentInfoKHRBuilder<'a> { pub fn src_rect(mut self, src_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a> { self.inner.src_rect = src_rect; @@ -16635,13 +17760,6 @@ impl<'a> DisplayPresentInfoKHRBuilder<'a> { self.inner.persistent = persistent.into(); self } - pub fn next(mut self, next: &'a T) -> DisplayPresentInfoKHRBuilder<'a> - where - T: ExtendsDisplayPresentInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DisplayPresentInfoKHR { self.inner } @@ -16678,6 +17796,11 @@ impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SurfaceCapabilitiesKHRBuilder<'a> { pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a> { self.inner.min_image_count = min_image_count; @@ -16774,13 +17897,20 @@ pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> { inner: AndroidSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAndroidSurfaceCreateInfoKHR {} +pub unsafe trait ExtendsAndroidSurfaceCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> { type Target = AndroidSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { pub fn flags( mut self, @@ -16793,11 +17923,20 @@ impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { self.inner.window = window; self } - pub fn next(mut self, next: &'a T) -> AndroidSurfaceCreateInfoKHRBuilder<'a> - where - T: ExtendsAndroidSurfaceCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AndroidSurfaceCreateInfoKHR { @@ -16834,13 +17973,20 @@ pub struct ViSurfaceCreateInfoNNBuilder<'a> { inner: ViSurfaceCreateInfoNN, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsViSurfaceCreateInfoNN {} +pub unsafe trait ExtendsViSurfaceCreateInfoNN { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> { type Target = ViSurfaceCreateInfoNN; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> ViSurfaceCreateInfoNNBuilder<'a> { self.inner.flags = flags; @@ -16850,11 +17996,20 @@ impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { self.inner.window = window; self } - pub fn next(mut self, next: &'a T) -> ViSurfaceCreateInfoNNBuilder<'a> - where - T: ExtendsViSurfaceCreateInfoNN, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ViSurfaceCreateInfoNNBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ViSurfaceCreateInfoNN { @@ -16893,13 +18048,20 @@ pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> { inner: WaylandSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWaylandSurfaceCreateInfoKHR {} +pub unsafe trait ExtendsWaylandSurfaceCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> { type Target = WaylandSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { pub fn flags( mut self, @@ -16916,11 +18078,20 @@ impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { self.inner.surface = surface; self } - pub fn next(mut self, next: &'a T) -> WaylandSurfaceCreateInfoKHRBuilder<'a> - where - T: ExtendsWaylandSurfaceCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> WaylandSurfaceCreateInfoKHR { @@ -16959,13 +18130,20 @@ pub struct Win32SurfaceCreateInfoKHRBuilder<'a> { inner: Win32SurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWin32SurfaceCreateInfoKHR {} +pub unsafe trait ExtendsWin32SurfaceCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> { type Target = Win32SurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { pub fn flags( mut self, @@ -16982,11 +18160,20 @@ impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { self.inner.hwnd = hwnd; self } - pub fn next(mut self, next: &'a T) -> Win32SurfaceCreateInfoKHRBuilder<'a> - where - T: ExtendsWin32SurfaceCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> Win32SurfaceCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> Win32SurfaceCreateInfoKHR { @@ -17025,13 +18212,20 @@ pub struct XlibSurfaceCreateInfoKHRBuilder<'a> { inner: XlibSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsXlibSurfaceCreateInfoKHR {} +pub unsafe trait ExtendsXlibSurfaceCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> { type Target = XlibSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { pub fn flags( mut self, @@ -17048,11 +18242,20 @@ impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { self.inner.window = window; self } - pub fn next(mut self, next: &'a T) -> XlibSurfaceCreateInfoKHRBuilder<'a> - where - T: ExtendsXlibSurfaceCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> XlibSurfaceCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> XlibSurfaceCreateInfoKHR { @@ -17091,13 +18294,20 @@ pub struct XcbSurfaceCreateInfoKHRBuilder<'a> { inner: XcbSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsXcbSurfaceCreateInfoKHR {} +pub unsafe trait ExtendsXcbSurfaceCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> { type Target = XcbSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> XcbSurfaceCreateInfoKHRBuilder<'a> { self.inner.flags = flags; @@ -17114,11 +18324,20 @@ impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { self.inner.window = window; self } - pub fn next(mut self, next: &'a T) -> XcbSurfaceCreateInfoKHRBuilder<'a> - where - T: ExtendsXcbSurfaceCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> XcbSurfaceCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> XcbSurfaceCreateInfoKHR { @@ -17155,13 +18374,20 @@ pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { inner: ImagePipeSurfaceCreateInfoFUCHSIA, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImagePipeSurfaceCreateInfoFUCHSIA {} +pub unsafe trait ExtendsImagePipeSurfaceCreateInfoFUCHSIA { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { type Target = ImagePipeSurfaceCreateInfoFUCHSIA; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { pub fn flags( mut self, @@ -17177,11 +18403,20 @@ impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { self.inner.image_pipe_handle = image_pipe_handle; self } - pub fn next(mut self, next: &'a T) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> - where - T: ExtendsImagePipeSurfaceCreateInfoFUCHSIA, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA { @@ -17212,6 +18447,11 @@ impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SurfaceFormatKHRBuilder<'a> { pub fn format(mut self, format: Format) -> SurfaceFormatKHRBuilder<'a> { self.inner.format = format; @@ -17283,13 +18523,20 @@ pub struct SwapchainCreateInfoKHRBuilder<'a> { inner: SwapchainCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSwapchainCreateInfoKHR {} +pub unsafe trait ExtendsSwapchainCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> { type Target = SwapchainCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SwapchainCreateInfoKHRBuilder<'a> { pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> SwapchainCreateInfoKHRBuilder<'a> { self.inner.flags = flags; @@ -17379,11 +18626,20 @@ impl<'a> SwapchainCreateInfoKHRBuilder<'a> { self.inner.old_swapchain = old_swapchain; self } - pub fn next(mut self, next: &'a T) -> SwapchainCreateInfoKHRBuilder<'a> - where - T: ExtendsSwapchainCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SwapchainCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SwapchainCreateInfoKHR { @@ -17428,13 +18684,20 @@ pub struct PresentInfoKHRBuilder<'a> { inner: PresentInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPresentInfoKHR {} +pub unsafe trait ExtendsPresentInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> { type Target = PresentInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PresentInfoKHRBuilder<'a> { pub fn wait_semaphores( mut self, @@ -17459,11 +18722,20 @@ impl<'a> PresentInfoKHRBuilder<'a> { self.inner.p_results = results.as_mut_ptr(); self } - pub fn next(mut self, next: &'a T) -> PresentInfoKHRBuilder<'a> - where - T: ExtendsPresentInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PresentInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PresentInfoKHR { @@ -17513,14 +18785,27 @@ pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> { inner: DebugReportCallbackCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugReportCallbackCreateInfoEXT {} -unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> { type Target = DebugReportCallbackCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> { pub fn flags( mut self, @@ -17543,13 +18828,6 @@ impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> { self.inner.p_user_data = user_data; self } - pub fn next(mut self, next: &'a T) -> DebugReportCallbackCreateInfoEXTBuilder<'a> - where - T: ExtendsDebugReportCallbackCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DebugReportCallbackCreateInfoEXT { self.inner } @@ -17584,14 +18862,27 @@ pub struct ValidationFlagsEXTBuilder<'a> { inner: ValidationFlagsEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsValidationFlagsEXT {} -unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> { type Target = ValidationFlagsEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ValidationFlagsEXTBuilder<'a> { pub fn disabled_validation_checks( mut self, @@ -17601,13 +18892,6 @@ impl<'a> ValidationFlagsEXTBuilder<'a> { self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> ValidationFlagsEXTBuilder<'a> - where - T: ExtendsValidationFlagsEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ValidationFlagsEXT { self.inner } @@ -17646,14 +18930,27 @@ pub struct ValidationFeaturesEXTBuilder<'a> { inner: ValidationFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsValidationFeaturesEXT {} -unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> { type Target = ValidationFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ValidationFeaturesEXTBuilder<'a> { pub fn enabled_validation_features( mut self, @@ -17671,13 +18968,6 @@ impl<'a> ValidationFeaturesEXTBuilder<'a> { self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> ValidationFeaturesEXTBuilder<'a> - where - T: ExtendsValidationFeaturesEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ValidationFeaturesEXT { self.inner } @@ -17710,10 +19000,19 @@ pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { inner: PipelineRasterizationStateRasterizationOrderAMD, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineRasterizationStateRasterizationOrderAMD {} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationStateRasterizationOrderAMD { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { type Target = PipelineRasterizationStateRasterizationOrderAMD; @@ -17721,6 +19020,11 @@ impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBu &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { pub fn rasterization_order( mut self, @@ -17729,16 +19033,6 @@ impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { self.inner.rasterization_order = rasterization_order; self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> - where - T: ExtendsPipelineRasterizationStateRasterizationOrderAMD, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD { self.inner } @@ -17775,13 +19069,20 @@ pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> { inner: DebugMarkerObjectNameInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerObjectNameInfoEXT {} +pub unsafe trait ExtendsDebugMarkerObjectNameInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> { type Target = DebugMarkerObjectNameInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { pub fn object_type( mut self, @@ -17801,11 +19102,20 @@ impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { self.inner.p_object_name = object_name.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DebugMarkerObjectNameInfoEXTBuilder<'a> - where - T: ExtendsDebugMarkerObjectNameInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DebugMarkerObjectNameInfoEXT { @@ -17848,13 +19158,20 @@ pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> { inner: DebugMarkerObjectTagInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerObjectTagInfoEXT {} +pub unsafe trait ExtendsDebugMarkerObjectTagInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> { type Target = DebugMarkerObjectTagInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { pub fn object_type( mut self, @@ -17876,11 +19193,20 @@ impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { self.inner.p_tag = tag.as_ptr() as *const c_void; self } - pub fn next(mut self, next: &'a T) -> DebugMarkerObjectTagInfoEXTBuilder<'a> - where - T: ExtendsDebugMarkerObjectTagInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DebugMarkerObjectTagInfoEXT { @@ -17917,13 +19243,20 @@ pub struct DebugMarkerMarkerInfoEXTBuilder<'a> { inner: DebugMarkerMarkerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerMarkerInfoEXT {} +pub unsafe trait ExtendsDebugMarkerMarkerInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> { type Target = DebugMarkerMarkerInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { pub fn marker_name( mut self, @@ -17936,11 +19269,20 @@ impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { self.inner.color = color; self } - pub fn next(mut self, next: &'a T) -> DebugMarkerMarkerInfoEXTBuilder<'a> - where - T: ExtendsDebugMarkerMarkerInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DebugMarkerMarkerInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DebugMarkerMarkerInfoEXT { @@ -17975,14 +19317,27 @@ pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> { inner: DedicatedAllocationImageCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDedicatedAllocationImageCreateInfoNV {} -unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> { type Target = DedicatedAllocationImageCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> { pub fn dedicated_allocation( mut self, @@ -17991,13 +19346,6 @@ impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> { self.inner.dedicated_allocation = dedicated_allocation.into(); self } - pub fn next(mut self, next: &'a T) -> DedicatedAllocationImageCreateInfoNVBuilder<'a> - where - T: ExtendsDedicatedAllocationImageCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DedicatedAllocationImageCreateInfoNV { self.inner } @@ -18030,14 +19378,27 @@ pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> { inner: DedicatedAllocationBufferCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDedicatedAllocationBufferCreateInfoNV {} -unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { type Target = DedicatedAllocationBufferCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { pub fn dedicated_allocation( mut self, @@ -18046,13 +19407,6 @@ impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { self.inner.dedicated_allocation = dedicated_allocation.into(); self } - pub fn next(mut self, next: &'a T) -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> - where - T: ExtendsDedicatedAllocationBufferCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV { self.inner } @@ -18087,14 +19441,27 @@ pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { inner: DedicatedAllocationMemoryAllocateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDedicatedAllocationMemoryAllocateInfoNV {} -unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { type Target = DedicatedAllocationMemoryAllocateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { pub fn image(mut self, image: Image) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { self.inner.image = image; @@ -18104,13 +19471,6 @@ impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { self.inner.buffer = buffer; self } - pub fn next(mut self, next: &'a T) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> - where - T: ExtendsDedicatedAllocationMemoryAllocateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV { self.inner } @@ -18141,6 +19501,11 @@ impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> { pub fn image_format_properties( mut self, @@ -18202,14 +19567,27 @@ pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> { inner: ExternalMemoryImageCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalMemoryImageCreateInfoNV {} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> { type Target = ExternalMemoryImageCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> { pub fn handle_types( mut self, @@ -18218,13 +19596,6 @@ impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> { self.inner.handle_types = handle_types; self } - pub fn next(mut self, next: &'a T) -> ExternalMemoryImageCreateInfoNVBuilder<'a> - where - T: ExtendsExternalMemoryImageCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExternalMemoryImageCreateInfoNV { self.inner } @@ -18257,14 +19628,27 @@ pub struct ExportMemoryAllocateInfoNVBuilder<'a> { inner: ExportMemoryAllocateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportMemoryAllocateInfoNV {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> { type Target = ExportMemoryAllocateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> { pub fn handle_types( mut self, @@ -18273,13 +19657,6 @@ impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> { self.inner.handle_types = handle_types; self } - pub fn next(mut self, next: &'a T) -> ExportMemoryAllocateInfoNVBuilder<'a> - where - T: ExtendsExportMemoryAllocateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportMemoryAllocateInfoNV { self.inner } @@ -18314,14 +19691,27 @@ pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> { inner: ImportMemoryWin32HandleInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportMemoryWin32HandleInfoNV {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> { type Target = ImportMemoryWin32HandleInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> { pub fn handle_type( mut self, @@ -18334,13 +19724,6 @@ impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> { self.inner.handle = handle; self } - pub fn next(mut self, next: &'a T) -> ImportMemoryWin32HandleInfoNVBuilder<'a> - where - T: ExtendsImportMemoryWin32HandleInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImportMemoryWin32HandleInfoNV { self.inner } @@ -18375,14 +19758,27 @@ pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> { inner: ExportMemoryWin32HandleInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportMemoryWin32HandleInfoNV {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> { type Target = ExportMemoryWin32HandleInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> { pub fn attributes( mut self, @@ -18395,13 +19791,6 @@ impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> { self.inner.dw_access = dw_access; self } - pub fn next(mut self, next: &'a T) -> ExportMemoryWin32HandleInfoNVBuilder<'a> - where - T: ExtendsExportMemoryWin32HandleInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportMemoryWin32HandleInfoNV { self.inner } @@ -18446,14 +19835,27 @@ pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { inner: Win32KeyedMutexAcquireReleaseInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWin32KeyedMutexAcquireReleaseInfoNV {} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { type Target = Win32KeyedMutexAcquireReleaseInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { pub fn acquire_syncs( mut self, @@ -18495,13 +19897,6 @@ impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { self.inner.p_release_keys = release_keys.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> - where - T: ExtendsWin32KeyedMutexAcquireReleaseInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV { self.inner } @@ -18534,13 +19929,20 @@ pub struct DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { inner: DeviceGeneratedCommandsFeaturesNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGeneratedCommandsFeaturesNVX {} +pub unsafe trait ExtendsDeviceGeneratedCommandsFeaturesNVX { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { type Target = DeviceGeneratedCommandsFeaturesNVX; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { pub fn compute_binding_point_support( mut self, @@ -18549,11 +19951,20 @@ impl<'a> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { self.inner.compute_binding_point_support = compute_binding_point_support.into(); self } - pub fn next(mut self, next: &'a T) -> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> - where - T: ExtendsDeviceGeneratedCommandsFeaturesNVX, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DeviceGeneratedCommandsFeaturesNVX { @@ -18596,13 +20007,20 @@ pub struct DeviceGeneratedCommandsLimitsNVXBuilder<'a> { inner: DeviceGeneratedCommandsLimitsNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGeneratedCommandsLimitsNVX {} +pub unsafe trait ExtendsDeviceGeneratedCommandsLimitsNVX { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DeviceGeneratedCommandsLimitsNVXBuilder<'a> { type Target = DeviceGeneratedCommandsLimitsNVX; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { pub fn max_indirect_commands_layout_token_count( mut self, @@ -18643,11 +20061,20 @@ impl<'a> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { min_commands_token_buffer_offset_alignment; self } - pub fn next(mut self, next: &'a T) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> - where - T: ExtendsDeviceGeneratedCommandsLimitsNVX, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DeviceGeneratedCommandsLimitsNVX { @@ -18679,6 +20106,11 @@ impl<'a> ::std::ops::Deref for IndirectCommandsTokenNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for IndirectCommandsTokenNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> IndirectCommandsTokenNVXBuilder<'a> { pub fn token_type( mut self, @@ -18725,6 +20157,11 @@ impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> IndirectCommandsLayoutTokenNVXBuilder<'a> { pub fn token_type( mut self, @@ -18786,13 +20223,20 @@ pub struct IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { inner: IndirectCommandsLayoutCreateInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsIndirectCommandsLayoutCreateInfoNVX {} +pub unsafe trait ExtendsIndirectCommandsLayoutCreateInfoNVX { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { type Target = IndirectCommandsLayoutCreateInfoNVX; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { pub fn pipeline_bind_point( mut self, @@ -18816,11 +20260,20 @@ impl<'a> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { self.inner.p_tokens = tokens.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> - where - T: ExtendsIndirectCommandsLayoutCreateInfoNVX, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> IndirectCommandsLayoutCreateInfoNVX { @@ -18873,13 +20326,20 @@ pub struct CmdProcessCommandsInfoNVXBuilder<'a> { inner: CmdProcessCommandsInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCmdProcessCommandsInfoNVX {} +pub unsafe trait ExtendsCmdProcessCommandsInfoNVX { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CmdProcessCommandsInfoNVXBuilder<'a> { type Target = CmdProcessCommandsInfoNVX; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CmdProcessCommandsInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CmdProcessCommandsInfoNVXBuilder<'a> { pub fn object_table( mut self, @@ -18945,11 +20405,20 @@ impl<'a> CmdProcessCommandsInfoNVXBuilder<'a> { self.inner.sequences_index_offset = sequences_index_offset; self } - pub fn next(mut self, next: &'a T) -> CmdProcessCommandsInfoNVXBuilder<'a> - where - T: ExtendsCmdProcessCommandsInfoNVX, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CmdProcessCommandsInfoNVXBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CmdProcessCommandsInfoNVX { @@ -18988,13 +20457,20 @@ pub struct CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { inner: CmdReserveSpaceForCommandsInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCmdReserveSpaceForCommandsInfoNVX {} +pub unsafe trait ExtendsCmdReserveSpaceForCommandsInfoNVX { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { type Target = CmdReserveSpaceForCommandsInfoNVX; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { pub fn object_table( mut self, @@ -19017,11 +20493,20 @@ impl<'a> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { self.inner.max_sequences_count = max_sequences_count; self } - pub fn next(mut self, next: &'a T) -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> - where - T: ExtendsCmdReserveSpaceForCommandsInfoNVX, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CmdReserveSpaceForCommandsInfoNVX { @@ -19072,13 +20557,20 @@ pub struct ObjectTableCreateInfoNVXBuilder<'a> { inner: ObjectTableCreateInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsObjectTableCreateInfoNVX {} +pub unsafe trait ExtendsObjectTableCreateInfoNVX { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ObjectTableCreateInfoNVXBuilder<'a> { type Target = ObjectTableCreateInfoNVX; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ObjectTableCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ObjectTableCreateInfoNVXBuilder<'a> { pub fn object_entry_types( mut self, @@ -19139,11 +20631,20 @@ impl<'a> ObjectTableCreateInfoNVXBuilder<'a> { self.inner.max_pipeline_layouts = max_pipeline_layouts; self } - pub fn next(mut self, next: &'a T) -> ObjectTableCreateInfoNVXBuilder<'a> - where - T: ExtendsObjectTableCreateInfoNVX, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ObjectTableCreateInfoNVXBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ObjectTableCreateInfoNVX { @@ -19174,6 +20675,11 @@ impl<'a> ::std::ops::Deref for ObjectTableEntryNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ObjectTableEntryNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ObjectTableEntryNVXBuilder<'a> { pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableEntryNVXBuilder<'a> { self.inner.ty = ty; @@ -19212,6 +20718,11 @@ impl<'a> ::std::ops::Deref for ObjectTablePipelineEntryNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ObjectTablePipelineEntryNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ObjectTablePipelineEntryNVXBuilder<'a> { pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTablePipelineEntryNVXBuilder<'a> { self.inner.ty = ty; @@ -19258,6 +20769,11 @@ impl<'a> ::std::ops::Deref for ObjectTableDescriptorSetEntryNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ObjectTableDescriptorSetEntryNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ObjectTableDescriptorSetEntryNVXBuilder<'a> { pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableDescriptorSetEntryNVXBuilder<'a> { self.inner.ty = ty; @@ -19313,6 +20829,11 @@ impl<'a> ::std::ops::Deref for ObjectTableVertexBufferEntryNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ObjectTableVertexBufferEntryNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ObjectTableVertexBufferEntryNVXBuilder<'a> { pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableVertexBufferEntryNVXBuilder<'a> { self.inner.ty = ty; @@ -19359,6 +20880,11 @@ impl<'a> ::std::ops::Deref for ObjectTableIndexBufferEntryNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ObjectTableIndexBufferEntryNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ObjectTableIndexBufferEntryNVXBuilder<'a> { pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTableIndexBufferEntryNVXBuilder<'a> { self.inner.ty = ty; @@ -19412,6 +20938,11 @@ impl<'a> ::std::ops::Deref for ObjectTablePushConstantEntryNVXBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ObjectTablePushConstantEntryNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ObjectTablePushConstantEntryNVXBuilder<'a> { pub fn ty(mut self, ty: ObjectEntryTypeNVX) -> ObjectTablePushConstantEntryNVXBuilder<'a> { self.inner.ty = ty; @@ -19470,14 +21001,27 @@ pub struct PhysicalDeviceFeatures2Builder<'a> { inner: PhysicalDeviceFeatures2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceFeatures2 {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> { type Target = PhysicalDeviceFeatures2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceFeatures2Builder<'a> { pub fn features( mut self, @@ -19486,13 +21030,6 @@ impl<'a> PhysicalDeviceFeatures2Builder<'a> { self.inner.features = features; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceFeatures2Builder<'a> - where - T: ExtendsPhysicalDeviceFeatures2, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceFeatures2 { self.inner } @@ -19525,13 +21062,20 @@ pub struct PhysicalDeviceProperties2Builder<'a> { inner: PhysicalDeviceProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceProperties2 {} +pub unsafe trait ExtendsPhysicalDeviceProperties2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> { type Target = PhysicalDeviceProperties2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceProperties2Builder<'a> { pub fn properties( mut self, @@ -19540,11 +21084,20 @@ impl<'a> PhysicalDeviceProperties2Builder<'a> { self.inner.properties = properties; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceProperties2Builder<'a> - where - T: ExtendsPhysicalDeviceProperties2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceProperties2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceProperties2 { @@ -19579,13 +21132,20 @@ pub struct FormatProperties2Builder<'a> { inner: FormatProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFormatProperties2 {} +pub unsafe trait ExtendsFormatProperties2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> { type Target = FormatProperties2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> FormatProperties2Builder<'a> { pub fn format_properties( mut self, @@ -19594,11 +21154,20 @@ impl<'a> FormatProperties2Builder<'a> { self.inner.format_properties = format_properties; self } - pub fn next(mut self, next: &'a mut T) -> FormatProperties2Builder<'a> - where - T: ExtendsFormatProperties2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> FormatProperties2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> FormatProperties2 { @@ -19633,13 +21202,20 @@ pub struct ImageFormatProperties2Builder<'a> { inner: ImageFormatProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageFormatProperties2 {} +pub unsafe trait ExtendsImageFormatProperties2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> { type Target = ImageFormatProperties2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageFormatProperties2Builder<'a> { pub fn image_format_properties( mut self, @@ -19648,11 +21224,20 @@ impl<'a> ImageFormatProperties2Builder<'a> { self.inner.image_format_properties = image_format_properties; self } - pub fn next(mut self, next: &'a mut T) -> ImageFormatProperties2Builder<'a> - where - T: ExtendsImageFormatProperties2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImageFormatProperties2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImageFormatProperties2 { @@ -19695,13 +21280,20 @@ pub struct PhysicalDeviceImageFormatInfo2Builder<'a> { inner: PhysicalDeviceImageFormatInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {} +pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> { type Target = PhysicalDeviceImageFormatInfo2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { pub fn format(mut self, format: Format) -> PhysicalDeviceImageFormatInfo2Builder<'a> { self.inner.format = format; @@ -19723,11 +21315,20 @@ impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { self.inner.flags = flags; self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceImageFormatInfo2Builder<'a> - where - T: ExtendsPhysicalDeviceImageFormatInfo2, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceImageFormatInfo2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceImageFormatInfo2 { @@ -19762,13 +21363,20 @@ pub struct QueueFamilyProperties2Builder<'a> { inner: QueueFamilyProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsQueueFamilyProperties2 {} +pub unsafe trait ExtendsQueueFamilyProperties2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> { type Target = QueueFamilyProperties2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> QueueFamilyProperties2Builder<'a> { pub fn queue_family_properties( mut self, @@ -19777,11 +21385,20 @@ impl<'a> QueueFamilyProperties2Builder<'a> { self.inner.queue_family_properties = queue_family_properties; self } - pub fn next(mut self, next: &'a mut T) -> QueueFamilyProperties2Builder<'a> - where - T: ExtendsQueueFamilyProperties2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> QueueFamilyProperties2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> QueueFamilyProperties2 { @@ -19816,13 +21433,20 @@ pub struct PhysicalDeviceMemoryProperties2Builder<'a> { inner: PhysicalDeviceMemoryProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {} +pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> { type Target = PhysicalDeviceMemoryProperties2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { pub fn memory_properties( mut self, @@ -19831,11 +21455,20 @@ impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { self.inner.memory_properties = memory_properties; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryProperties2Builder<'a> - where - T: ExtendsPhysicalDeviceMemoryProperties2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceMemoryProperties2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceMemoryProperties2 { @@ -19870,13 +21503,20 @@ pub struct SparseImageFormatProperties2Builder<'a> { inner: SparseImageFormatProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSparseImageFormatProperties2 {} +pub unsafe trait ExtendsSparseImageFormatProperties2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> { type Target = SparseImageFormatProperties2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseImageFormatProperties2Builder<'a> { pub fn properties( mut self, @@ -19885,11 +21525,20 @@ impl<'a> SparseImageFormatProperties2Builder<'a> { self.inner.properties = properties; self } - pub fn next(mut self, next: &'a mut T) -> SparseImageFormatProperties2Builder<'a> - where - T: ExtendsSparseImageFormatProperties2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SparseImageFormatProperties2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SparseImageFormatProperties2 { @@ -19932,13 +21581,20 @@ pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> { inner: PhysicalDeviceSparseImageFormatInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSparseImageFormatInfo2 {} +pub unsafe trait ExtendsPhysicalDeviceSparseImageFormatInfo2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { type Target = PhysicalDeviceSparseImageFormatInfo2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { pub fn format(mut self, format: Format) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { self.inner.format = format; @@ -19969,11 +21625,20 @@ impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { self.inner.tiling = tiling; self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> - where - T: ExtendsPhysicalDeviceSparseImageFormatInfo2, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 { @@ -20008,14 +21673,29 @@ pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { inner: PhysicalDevicePushDescriptorPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDevicePushDescriptorPropertiesKHR {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { type Target = PhysicalDevicePushDescriptorPropertiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { pub fn max_push_descriptors( mut self, @@ -20024,16 +21704,6 @@ impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { self.inner.max_push_descriptors = max_push_descriptors; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> - where - T: ExtendsPhysicalDevicePushDescriptorPropertiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR { self.inner } @@ -20064,6 +21734,11 @@ impl<'a> ::std::ops::Deref for ConformanceVersionKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ConformanceVersionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ConformanceVersionKHRBuilder<'a> { pub fn major(mut self, major: u8) -> ConformanceVersionKHRBuilder<'a> { self.inner.major = major; @@ -20135,14 +21810,27 @@ pub struct PhysicalDeviceDriverPropertiesKHRBuilder<'a> { inner: PhysicalDeviceDriverPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceDriverPropertiesKHR {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesKHR {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesKHRBuilder<'a> { type Target = PhysicalDeviceDriverPropertiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceDriverPropertiesKHRBuilder<'a> { pub fn driver_id( mut self, @@ -20172,13 +21860,6 @@ impl<'a> PhysicalDeviceDriverPropertiesKHRBuilder<'a> { self.inner.conformance_version = conformance_version; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceDriverPropertiesKHRBuilder<'a> - where - T: ExtendsPhysicalDeviceDriverPropertiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceDriverPropertiesKHR { self.inner } @@ -20213,27 +21894,33 @@ pub struct PresentRegionsKHRBuilder<'a> { inner: PresentRegionsKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPresentRegionsKHR {} -unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> { type Target = PresentRegionsKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PresentRegionsKHRBuilder<'a> { pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> PresentRegionsKHRBuilder<'a> { self.inner.swapchain_count = regions.len() as _; self.inner.p_regions = regions.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PresentRegionsKHRBuilder<'a> - where - T: ExtendsPresentRegionsKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PresentRegionsKHR { self.inner } @@ -20270,6 +21957,11 @@ impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PresentRegionKHRBuilder<'a> { pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> PresentRegionKHRBuilder<'a> { self.inner.rectangle_count = rectangles.len() as _; @@ -20305,6 +21997,11 @@ impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RectLayerKHRBuilder<'a> { pub fn offset(mut self, offset: Offset2D) -> RectLayerKHRBuilder<'a> { self.inner.offset = offset; @@ -20352,15 +22049,27 @@ pub struct PhysicalDeviceVariablePointerFeaturesBuilder<'a> { inner: PhysicalDeviceVariablePointerFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceVariablePointerFeatures {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointerFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointerFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointerFeaturesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointerFeatures { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointerFeaturesBuilder<'a> { type Target = PhysicalDeviceVariablePointerFeatures; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointerFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceVariablePointerFeaturesBuilder<'a> { pub fn variable_pointers_storage_buffer( mut self, @@ -20376,13 +22085,6 @@ impl<'a> PhysicalDeviceVariablePointerFeaturesBuilder<'a> { self.inner.variable_pointers = variable_pointers.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceVariablePointerFeaturesBuilder<'a> - where - T: ExtendsPhysicalDeviceVariablePointerFeatures, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceVariablePointerFeatures { self.inner } @@ -20412,6 +22114,11 @@ impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalMemoryPropertiesBuilder<'a> { pub fn external_memory_features( mut self, @@ -20466,14 +22173,29 @@ pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> { inner: PhysicalDeviceExternalImageFormatInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalImageFormatInfo {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceExternalImageFormatInfoBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { type Target = PhysicalDeviceExternalImageFormatInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { pub fn handle_type( mut self, @@ -20482,13 +22204,6 @@ impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> - where - T: ExtendsPhysicalDeviceExternalImageFormatInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo { self.inner } @@ -20521,14 +22236,27 @@ pub struct ExternalImageFormatPropertiesBuilder<'a> { inner: ExternalImageFormatProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalImageFormatProperties {} -unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> { type Target = ExternalImageFormatProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalImageFormatPropertiesBuilder<'a> { pub fn external_memory_properties( mut self, @@ -20537,13 +22265,6 @@ impl<'a> ExternalImageFormatPropertiesBuilder<'a> { self.inner.external_memory_properties = external_memory_properties; self } - pub fn next(mut self, next: &'a mut T) -> ExternalImageFormatPropertiesBuilder<'a> - where - T: ExtendsExternalImageFormatProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> ExternalImageFormatProperties { self.inner } @@ -20580,13 +22301,20 @@ pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> { inner: PhysicalDeviceExternalBufferInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo {} +pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> { type Target = PhysicalDeviceExternalBufferInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { pub fn flags( mut self, @@ -20606,11 +22334,20 @@ impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceExternalBufferInfoBuilder<'a> - where - T: ExtendsPhysicalDeviceExternalBufferInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceExternalBufferInfo { @@ -20645,13 +22382,20 @@ pub struct ExternalBufferPropertiesBuilder<'a> { inner: ExternalBufferProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalBufferProperties {} +pub unsafe trait ExtendsExternalBufferProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> { type Target = ExternalBufferProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalBufferPropertiesBuilder<'a> { pub fn external_memory_properties( mut self, @@ -20660,11 +22404,20 @@ impl<'a> ExternalBufferPropertiesBuilder<'a> { self.inner.external_memory_properties = external_memory_properties; self } - pub fn next(mut self, next: &'a mut T) -> ExternalBufferPropertiesBuilder<'a> - where - T: ExtendsExternalBufferProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ExternalBufferPropertiesBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ExternalBufferProperties { @@ -20707,14 +22460,27 @@ pub struct PhysicalDeviceIDPropertiesBuilder<'a> { inner: PhysicalDeviceIDProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceIDProperties {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> { type Target = PhysicalDeviceIDProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> { pub fn device_uuid( mut self, @@ -20751,13 +22517,6 @@ impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> { self.inner.device_luid_valid = device_luid_valid.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceIDPropertiesBuilder<'a> - where - T: ExtendsPhysicalDeviceIDProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceIDProperties { self.inner } @@ -20790,14 +22549,27 @@ pub struct ExternalMemoryImageCreateInfoBuilder<'a> { inner: ExternalMemoryImageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalMemoryImageCreateInfo {} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> { type Target = ExternalMemoryImageCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> { pub fn handle_types( mut self, @@ -20806,13 +22578,6 @@ impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> { self.inner.handle_types = handle_types; self } - pub fn next(mut self, next: &'a T) -> ExternalMemoryImageCreateInfoBuilder<'a> - where - T: ExtendsExternalMemoryImageCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExternalMemoryImageCreateInfo { self.inner } @@ -20845,14 +22610,27 @@ pub struct ExternalMemoryBufferCreateInfoBuilder<'a> { inner: ExternalMemoryBufferCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalMemoryBufferCreateInfo {} -unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> { type Target = ExternalMemoryBufferCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> { pub fn handle_types( mut self, @@ -20861,13 +22639,6 @@ impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> { self.inner.handle_types = handle_types; self } - pub fn next(mut self, next: &'a T) -> ExternalMemoryBufferCreateInfoBuilder<'a> - where - T: ExtendsExternalMemoryBufferCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExternalMemoryBufferCreateInfo { self.inner } @@ -20900,14 +22671,27 @@ pub struct ExportMemoryAllocateInfoBuilder<'a> { inner: ExportMemoryAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportMemoryAllocateInfo {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> { type Target = ExportMemoryAllocateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportMemoryAllocateInfoBuilder<'a> { pub fn handle_types( mut self, @@ -20916,13 +22700,6 @@ impl<'a> ExportMemoryAllocateInfoBuilder<'a> { self.inner.handle_types = handle_types; self } - pub fn next(mut self, next: &'a T) -> ExportMemoryAllocateInfoBuilder<'a> - where - T: ExtendsExportMemoryAllocateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportMemoryAllocateInfo { self.inner } @@ -20959,14 +22736,27 @@ pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> { inner: ImportMemoryWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportMemoryWin32HandleInfoKHR {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> { type Target = ImportMemoryWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> { pub fn handle_type( mut self, @@ -20983,13 +22773,6 @@ impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - pub fn next(mut self, next: &'a T) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsImportMemoryWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImportMemoryWin32HandleInfoKHR { self.inner } @@ -21026,14 +22809,27 @@ pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> { inner: ExportMemoryWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportMemoryWin32HandleInfoKHR {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> { type Target = ExportMemoryWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> { pub fn attributes( mut self, @@ -21050,13 +22846,6 @@ impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - pub fn next(mut self, next: &'a T) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsExportMemoryWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportMemoryWin32HandleInfoKHR { self.inner } @@ -21089,13 +22878,20 @@ pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> { inner: MemoryWin32HandlePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryWin32HandlePropertiesKHR {} +pub unsafe trait ExtendsMemoryWin32HandlePropertiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> { type Target = MemoryWin32HandlePropertiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { pub fn memory_type_bits( mut self, @@ -21104,11 +22900,20 @@ impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - pub fn next(mut self, next: &'a mut T) -> MemoryWin32HandlePropertiesKHRBuilder<'a> - where - T: ExtendsMemoryWin32HandlePropertiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryWin32HandlePropertiesKHR { @@ -21145,13 +22950,20 @@ pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> { inner: MemoryGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetWin32HandleInfoKHR {} +pub unsafe trait ExtendsMemoryGetWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> { type Target = MemoryGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetWin32HandleInfoKHRBuilder<'a> { self.inner.memory = memory; @@ -21164,11 +22976,20 @@ impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> MemoryGetWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsMemoryGetWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryGetWin32HandleInfoKHR { @@ -21205,14 +23026,27 @@ pub struct ImportMemoryFdInfoKHRBuilder<'a> { inner: ImportMemoryFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportMemoryFdInfoKHR {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> { type Target = ImportMemoryFdInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportMemoryFdInfoKHRBuilder<'a> { pub fn handle_type( mut self, @@ -21225,13 +23059,6 @@ impl<'a> ImportMemoryFdInfoKHRBuilder<'a> { self.inner.fd = fd; self } - pub fn next(mut self, next: &'a T) -> ImportMemoryFdInfoKHRBuilder<'a> - where - T: ExtendsImportMemoryFdInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImportMemoryFdInfoKHR { self.inner } @@ -21264,23 +23091,39 @@ pub struct MemoryFdPropertiesKHRBuilder<'a> { inner: MemoryFdPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryFdPropertiesKHR {} +pub unsafe trait ExtendsMemoryFdPropertiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> { type Target = MemoryFdPropertiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryFdPropertiesKHRBuilder<'a> { pub fn memory_type_bits(mut self, memory_type_bits: u32) -> MemoryFdPropertiesKHRBuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - pub fn next(mut self, next: &'a mut T) -> MemoryFdPropertiesKHRBuilder<'a> - where - T: ExtendsMemoryFdPropertiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryFdPropertiesKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryFdPropertiesKHR { @@ -21317,13 +23160,20 @@ pub struct MemoryGetFdInfoKHRBuilder<'a> { inner: MemoryGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetFdInfoKHR {} +pub unsafe trait ExtendsMemoryGetFdInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> { type Target = MemoryGetFdInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryGetFdInfoKHRBuilder<'a> { pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetFdInfoKHRBuilder<'a> { self.inner.memory = memory; @@ -21336,11 +23186,20 @@ impl<'a> MemoryGetFdInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> MemoryGetFdInfoKHRBuilder<'a> - where - T: ExtendsMemoryGetFdInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryGetFdInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryGetFdInfoKHR { @@ -21387,14 +23246,27 @@ pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { inner: Win32KeyedMutexAcquireReleaseInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWin32KeyedMutexAcquireReleaseInfoKHR {} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { type Target = Win32KeyedMutexAcquireReleaseInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { pub fn acquire_syncs( mut self, @@ -21436,13 +23308,6 @@ impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { self.inner.p_release_keys = release_keys.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> - where - T: ExtendsWin32KeyedMutexAcquireReleaseInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR { self.inner } @@ -21475,13 +23340,20 @@ pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { inner: PhysicalDeviceExternalSemaphoreInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {} +pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { type Target = PhysicalDeviceExternalSemaphoreInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { pub fn handle_type( mut self, @@ -21490,11 +23362,20 @@ impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> - where - T: ExtendsPhysicalDeviceExternalSemaphoreInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo { @@ -21533,13 +23414,20 @@ pub struct ExternalSemaphorePropertiesBuilder<'a> { inner: ExternalSemaphoreProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalSemaphoreProperties {} +pub unsafe trait ExtendsExternalSemaphoreProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> { type Target = ExternalSemaphoreProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalSemaphorePropertiesBuilder<'a> { pub fn export_from_imported_handle_types( mut self, @@ -21562,11 +23450,20 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> { self.inner.external_semaphore_features = external_semaphore_features; self } - pub fn next(mut self, next: &'a mut T) -> ExternalSemaphorePropertiesBuilder<'a> - where - T: ExtendsExternalSemaphoreProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ExternalSemaphorePropertiesBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ExternalSemaphoreProperties { @@ -21601,14 +23498,27 @@ pub struct ExportSemaphoreCreateInfoBuilder<'a> { inner: ExportSemaphoreCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportSemaphoreCreateInfo {} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> { type Target = ExportSemaphoreCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportSemaphoreCreateInfoBuilder<'a> { pub fn handle_types( mut self, @@ -21617,13 +23527,6 @@ impl<'a> ExportSemaphoreCreateInfoBuilder<'a> { self.inner.handle_types = handle_types; self } - pub fn next(mut self, next: &'a T) -> ExportSemaphoreCreateInfoBuilder<'a> - where - T: ExtendsExportSemaphoreCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportSemaphoreCreateInfo { self.inner } @@ -21664,13 +23567,20 @@ pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { inner: ImportSemaphoreWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportSemaphoreWin32HandleInfoKHR {} +pub unsafe trait ExtendsImportSemaphoreWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { type Target = ImportSemaphoreWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { pub fn semaphore( mut self, @@ -21701,11 +23611,20 @@ impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - pub fn next(mut self, next: &'a T) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsImportSemaphoreWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR { @@ -21744,14 +23663,27 @@ pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { inner: ExportSemaphoreWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportSemaphoreWin32HandleInfoKHR {} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { type Target = ExportSemaphoreWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { pub fn attributes( mut self, @@ -21768,13 +23700,6 @@ impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - pub fn next(mut self, next: &'a T) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsExportSemaphoreWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR { self.inner } @@ -21813,14 +23738,27 @@ pub struct D3D12FenceSubmitInfoKHRBuilder<'a> { inner: D3D12FenceSubmitInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsD3D12FenceSubmitInfoKHR {} -unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> { type Target = D3D12FenceSubmitInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { pub fn wait_semaphore_values( mut self, @@ -21838,13 +23776,6 @@ impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> D3D12FenceSubmitInfoKHRBuilder<'a> - where - T: ExtendsD3D12FenceSubmitInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> D3D12FenceSubmitInfoKHR { self.inner } @@ -21879,13 +23810,20 @@ pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> { inner: SemaphoreGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreGetWin32HandleInfoKHR {} +pub unsafe trait ExtendsSemaphoreGetWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { type Target = SemaphoreGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { self.inner.semaphore = semaphore; @@ -21898,11 +23836,20 @@ impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsSemaphoreGetWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR { @@ -21943,13 +23890,20 @@ pub struct ImportSemaphoreFdInfoKHRBuilder<'a> { inner: ImportSemaphoreFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportSemaphoreFdInfoKHR {} +pub unsafe trait ExtendsImportSemaphoreFdInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> { type Target = ImportSemaphoreFdInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { pub fn semaphore(mut self, semaphore: Semaphore) -> ImportSemaphoreFdInfoKHRBuilder<'a> { self.inner.semaphore = semaphore; @@ -21970,11 +23924,20 @@ impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { self.inner.fd = fd; self } - pub fn next(mut self, next: &'a T) -> ImportSemaphoreFdInfoKHRBuilder<'a> - where - T: ExtendsImportSemaphoreFdInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImportSemaphoreFdInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImportSemaphoreFdInfoKHR { @@ -22011,13 +23974,20 @@ pub struct SemaphoreGetFdInfoKHRBuilder<'a> { inner: SemaphoreGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreGetFdInfoKHR {} +pub unsafe trait ExtendsSemaphoreGetFdInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> { type Target = SemaphoreGetFdInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetFdInfoKHRBuilder<'a> { self.inner.semaphore = semaphore; @@ -22030,11 +24000,20 @@ impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> SemaphoreGetFdInfoKHRBuilder<'a> - where - T: ExtendsSemaphoreGetFdInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SemaphoreGetFdInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SemaphoreGetFdInfoKHR { @@ -22069,13 +24048,20 @@ pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> { inner: PhysicalDeviceExternalFenceInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalFenceInfo {} +pub unsafe trait ExtendsPhysicalDeviceExternalFenceInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> { type Target = PhysicalDeviceExternalFenceInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { pub fn handle_type( mut self, @@ -22084,11 +24070,20 @@ impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceExternalFenceInfoBuilder<'a> - where - T: ExtendsPhysicalDeviceExternalFenceInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceExternalFenceInfo { @@ -22127,13 +24122,20 @@ pub struct ExternalFencePropertiesBuilder<'a> { inner: ExternalFenceProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalFenceProperties {} +pub unsafe trait ExtendsExternalFenceProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> { type Target = ExternalFenceProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalFencePropertiesBuilder<'a> { pub fn export_from_imported_handle_types( mut self, @@ -22156,11 +24158,20 @@ impl<'a> ExternalFencePropertiesBuilder<'a> { self.inner.external_fence_features = external_fence_features; self } - pub fn next(mut self, next: &'a mut T) -> ExternalFencePropertiesBuilder<'a> - where - T: ExtendsExternalFenceProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ExternalFencePropertiesBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ExternalFenceProperties { @@ -22195,14 +24206,27 @@ pub struct ExportFenceCreateInfoBuilder<'a> { inner: ExportFenceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportFenceCreateInfo {} -unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> { type Target = ExportFenceCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportFenceCreateInfoBuilder<'a> { pub fn handle_types( mut self, @@ -22211,13 +24235,6 @@ impl<'a> ExportFenceCreateInfoBuilder<'a> { self.inner.handle_types = handle_types; self } - pub fn next(mut self, next: &'a T) -> ExportFenceCreateInfoBuilder<'a> - where - T: ExtendsExportFenceCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportFenceCreateInfo { self.inner } @@ -22258,13 +24275,20 @@ pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> { inner: ImportFenceWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportFenceWin32HandleInfoKHR {} +pub unsafe trait ExtendsImportFenceWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> { type Target = ImportFenceWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { pub fn fence(mut self, fence: Fence) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { self.inner.fence = fence; @@ -22289,11 +24313,20 @@ impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - pub fn next(mut self, next: &'a T) -> ImportFenceWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsImportFenceWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImportFenceWin32HandleInfoKHR { @@ -22332,14 +24365,27 @@ pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> { inner: ExportFenceWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExportFenceWin32HandleInfoKHR {} -unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> { type Target = ExportFenceWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> { pub fn attributes( mut self, @@ -22356,13 +24402,6 @@ impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - pub fn next(mut self, next: &'a T) -> ExportFenceWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsExportFenceWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ExportFenceWin32HandleInfoKHR { self.inner } @@ -22397,13 +24436,20 @@ pub struct FenceGetWin32HandleInfoKHRBuilder<'a> { inner: FenceGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceGetWin32HandleInfoKHR {} +pub unsafe trait ExtendsFenceGetWin32HandleInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> { type Target = FenceGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { pub fn fence(mut self, fence: Fence) -> FenceGetWin32HandleInfoKHRBuilder<'a> { self.inner.fence = fence; @@ -22416,11 +24462,20 @@ impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> FenceGetWin32HandleInfoKHRBuilder<'a> - where - T: ExtendsFenceGetWin32HandleInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> FenceGetWin32HandleInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> FenceGetWin32HandleInfoKHR { @@ -22461,13 +24516,20 @@ pub struct ImportFenceFdInfoKHRBuilder<'a> { inner: ImportFenceFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportFenceFdInfoKHR {} +pub unsafe trait ExtendsImportFenceFdInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> { type Target = ImportFenceFdInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportFenceFdInfoKHRBuilder<'a> { pub fn fence(mut self, fence: Fence) -> ImportFenceFdInfoKHRBuilder<'a> { self.inner.fence = fence; @@ -22488,11 +24550,20 @@ impl<'a> ImportFenceFdInfoKHRBuilder<'a> { self.inner.fd = fd; self } - pub fn next(mut self, next: &'a T) -> ImportFenceFdInfoKHRBuilder<'a> - where - T: ExtendsImportFenceFdInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImportFenceFdInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImportFenceFdInfoKHR { @@ -22529,13 +24600,20 @@ pub struct FenceGetFdInfoKHRBuilder<'a> { inner: FenceGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceGetFdInfoKHR {} +pub unsafe trait ExtendsFenceGetFdInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> { type Target = FenceGetFdInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> FenceGetFdInfoKHRBuilder<'a> { pub fn fence(mut self, fence: Fence) -> FenceGetFdInfoKHRBuilder<'a> { self.inner.fence = fence; @@ -22548,11 +24626,20 @@ impl<'a> FenceGetFdInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - pub fn next(mut self, next: &'a T) -> FenceGetFdInfoKHRBuilder<'a> - where - T: ExtendsFenceGetFdInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> FenceGetFdInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> FenceGetFdInfoKHR { @@ -22591,15 +24678,27 @@ pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> { inner: PhysicalDeviceMultiviewFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMultiviewFeatures {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> { type Target = PhysicalDeviceMultiviewFeatures; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> { pub fn multiview(mut self, multiview: bool) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { self.inner.multiview = multiview.into(); @@ -22619,13 +24718,6 @@ impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> { self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> - where - T: ExtendsPhysicalDeviceMultiviewFeatures, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMultiviewFeatures { self.inner } @@ -22660,14 +24752,27 @@ pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> { inner: PhysicalDeviceMultiviewProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMultiviewProperties {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> { type Target = PhysicalDeviceMultiviewProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> { pub fn max_multiview_view_count( mut self, @@ -22683,13 +24788,6 @@ impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> { self.inner.max_multiview_instance_index = max_multiview_instance_index; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMultiviewPropertiesBuilder<'a> - where - T: ExtendsPhysicalDeviceMultiviewProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMultiviewProperties { self.inner } @@ -22732,14 +24830,27 @@ pub struct RenderPassMultiviewCreateInfoBuilder<'a> { inner: RenderPassMultiviewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassMultiviewCreateInfo {} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> { type Target = RenderPassMultiviewCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { pub fn view_masks(mut self, view_masks: &'a [u32]) -> RenderPassMultiviewCreateInfoBuilder<'a> { self.inner.subpass_count = view_masks.len() as _; @@ -22762,13 +24873,6 @@ impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { self.inner.p_correlation_masks = correlation_masks.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> RenderPassMultiviewCreateInfoBuilder<'a> - where - T: ExtendsRenderPassMultiviewCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> RenderPassMultiviewCreateInfo { self.inner } @@ -22821,13 +24925,20 @@ pub struct SurfaceCapabilities2EXTBuilder<'a> { inner: SurfaceCapabilities2EXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceCapabilities2EXT {} +pub unsafe trait ExtendsSurfaceCapabilities2EXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> { type Target = SurfaceCapabilities2EXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SurfaceCapabilities2EXTBuilder<'a> { pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a> { self.inner.min_image_count = min_image_count; @@ -22900,11 +25011,20 @@ impl<'a> SurfaceCapabilities2EXTBuilder<'a> { self.inner.supported_surface_counters = supported_surface_counters; self } - pub fn next(mut self, next: &'a mut T) -> SurfaceCapabilities2EXTBuilder<'a> - where - T: ExtendsSurfaceCapabilities2EXT, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SurfaceCapabilities2EXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SurfaceCapabilities2EXT { @@ -22939,13 +25059,20 @@ pub struct DisplayPowerInfoEXTBuilder<'a> { inner: DisplayPowerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPowerInfoEXT {} +pub unsafe trait ExtendsDisplayPowerInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> { type Target = DisplayPowerInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPowerInfoEXTBuilder<'a> { pub fn power_state( mut self, @@ -22954,11 +25081,20 @@ impl<'a> DisplayPowerInfoEXTBuilder<'a> { self.inner.power_state = power_state; self } - pub fn next(mut self, next: &'a T) -> DisplayPowerInfoEXTBuilder<'a> - where - T: ExtendsDisplayPowerInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayPowerInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayPowerInfoEXT { @@ -22993,13 +25129,20 @@ pub struct DeviceEventInfoEXTBuilder<'a> { inner: DeviceEventInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceEventInfoEXT {} +pub unsafe trait ExtendsDeviceEventInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> { type Target = DeviceEventInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceEventInfoEXTBuilder<'a> { pub fn device_event( mut self, @@ -23008,11 +25151,20 @@ impl<'a> DeviceEventInfoEXTBuilder<'a> { self.inner.device_event = device_event; self } - pub fn next(mut self, next: &'a T) -> DeviceEventInfoEXTBuilder<'a> - where - T: ExtendsDeviceEventInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DeviceEventInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DeviceEventInfoEXT { @@ -23047,13 +25199,20 @@ pub struct DisplayEventInfoEXTBuilder<'a> { inner: DisplayEventInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayEventInfoEXT {} +pub unsafe trait ExtendsDisplayEventInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> { type Target = DisplayEventInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayEventInfoEXTBuilder<'a> { pub fn display_event( mut self, @@ -23062,11 +25221,20 @@ impl<'a> DisplayEventInfoEXTBuilder<'a> { self.inner.display_event = display_event; self } - pub fn next(mut self, next: &'a T) -> DisplayEventInfoEXTBuilder<'a> - where - T: ExtendsDisplayEventInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayEventInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayEventInfoEXT { @@ -23101,14 +25269,27 @@ pub struct SwapchainCounterCreateInfoEXTBuilder<'a> { inner: SwapchainCounterCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSwapchainCounterCreateInfoEXT {} -unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> { type Target = SwapchainCounterCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> { pub fn surface_counters( mut self, @@ -23117,13 +25298,6 @@ impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> { self.inner.surface_counters = surface_counters; self } - pub fn next(mut self, next: &'a T) -> SwapchainCounterCreateInfoEXTBuilder<'a> - where - T: ExtendsSwapchainCounterCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> SwapchainCounterCreateInfoEXT { self.inner } @@ -23160,13 +25334,20 @@ pub struct PhysicalDeviceGroupPropertiesBuilder<'a> { inner: PhysicalDeviceGroupProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceGroupProperties {} +pub unsafe trait ExtendsPhysicalDeviceGroupProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> { type Target = PhysicalDeviceGroupProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { pub fn physical_device_count( mut self, @@ -23189,11 +25370,20 @@ impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { self.inner.subset_allocation = subset_allocation.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceGroupPropertiesBuilder<'a> - where - T: ExtendsPhysicalDeviceGroupProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceGroupPropertiesBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceGroupProperties { @@ -23230,14 +25420,27 @@ pub struct MemoryAllocateFlagsInfoBuilder<'a> { inner: MemoryAllocateFlagsInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryAllocateFlagsInfo {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> { type Target = MemoryAllocateFlagsInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryAllocateFlagsInfoBuilder<'a> { pub fn flags(mut self, flags: MemoryAllocateFlags) -> MemoryAllocateFlagsInfoBuilder<'a> { self.inner.flags = flags; @@ -23247,13 +25450,6 @@ impl<'a> MemoryAllocateFlagsInfoBuilder<'a> { self.inner.device_mask = device_mask; self } - pub fn next(mut self, next: &'a T) -> MemoryAllocateFlagsInfoBuilder<'a> - where - T: ExtendsMemoryAllocateFlagsInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> MemoryAllocateFlagsInfo { self.inner } @@ -23290,13 +25486,20 @@ pub struct BindBufferMemoryInfoBuilder<'a> { inner: BindBufferMemoryInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindBufferMemoryInfo {} +pub unsafe trait ExtendsBindBufferMemoryInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> { type Target = BindBufferMemoryInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindBufferMemoryInfoBuilder<'a> { pub fn buffer(mut self, buffer: Buffer) -> BindBufferMemoryInfoBuilder<'a> { self.inner.buffer = buffer; @@ -23310,11 +25513,20 @@ impl<'a> BindBufferMemoryInfoBuilder<'a> { self.inner.memory_offset = memory_offset; self } - pub fn next(mut self, next: &'a T) -> BindBufferMemoryInfoBuilder<'a> - where - T: ExtendsBindBufferMemoryInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BindBufferMemoryInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BindBufferMemoryInfo { @@ -23351,14 +25563,27 @@ pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> { inner: BindBufferMemoryDeviceGroupInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindBufferMemoryDeviceGroupInfo {} -unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> { type Target = BindBufferMemoryDeviceGroupInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> { pub fn device_indices( mut self, @@ -23368,13 +25593,6 @@ impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> { self.inner.p_device_indices = device_indices.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> BindBufferMemoryDeviceGroupInfoBuilder<'a> - where - T: ExtendsBindBufferMemoryDeviceGroupInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> BindBufferMemoryDeviceGroupInfo { self.inner } @@ -23411,13 +25629,20 @@ pub struct BindImageMemoryInfoBuilder<'a> { inner: BindImageMemoryInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindImageMemoryInfo {} +pub unsafe trait ExtendsBindImageMemoryInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> { type Target = BindImageMemoryInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindImageMemoryInfoBuilder<'a> { pub fn image(mut self, image: Image) -> BindImageMemoryInfoBuilder<'a> { self.inner.image = image; @@ -23431,11 +25656,20 @@ impl<'a> BindImageMemoryInfoBuilder<'a> { self.inner.memory_offset = memory_offset; self } - pub fn next(mut self, next: &'a T) -> BindImageMemoryInfoBuilder<'a> - where - T: ExtendsBindImageMemoryInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BindImageMemoryInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BindImageMemoryInfo { @@ -23476,14 +25710,27 @@ pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> { inner: BindImageMemoryDeviceGroupInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindImageMemoryDeviceGroupInfo {} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> { type Target = BindImageMemoryDeviceGroupInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { pub fn device_indices( mut self, @@ -23501,13 +25748,6 @@ impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> BindImageMemoryDeviceGroupInfoBuilder<'a> - where - T: ExtendsBindImageMemoryDeviceGroupInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> BindImageMemoryDeviceGroupInfo { self.inner } @@ -23544,14 +25784,27 @@ pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> { inner: DeviceGroupRenderPassBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupRenderPassBeginInfo {} -unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> { type Target = DeviceGroupRenderPassBeginInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> { pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupRenderPassBeginInfoBuilder<'a> { self.inner.device_mask = device_mask; @@ -23565,13 +25818,6 @@ impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> { self.inner.p_device_render_areas = device_render_areas.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DeviceGroupRenderPassBeginInfoBuilder<'a> - where - T: ExtendsDeviceGroupRenderPassBeginInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceGroupRenderPassBeginInfo { self.inner } @@ -23604,26 +25850,32 @@ pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> { inner: DeviceGroupCommandBufferBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupCommandBufferBeginInfo {} -unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> { type Target = DeviceGroupCommandBufferBeginInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> { pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupCommandBufferBeginInfoBuilder<'a> { self.inner.device_mask = device_mask; self } - pub fn next(mut self, next: &'a T) -> DeviceGroupCommandBufferBeginInfoBuilder<'a> - where - T: ExtendsDeviceGroupCommandBufferBeginInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceGroupCommandBufferBeginInfo { self.inner } @@ -23666,14 +25918,27 @@ pub struct DeviceGroupSubmitInfoBuilder<'a> { inner: DeviceGroupSubmitInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupSubmitInfo {} -unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> { type Target = DeviceGroupSubmitInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupSubmitInfoBuilder<'a> { pub fn wait_semaphore_device_indices( mut self, @@ -23699,13 +25964,6 @@ impl<'a> DeviceGroupSubmitInfoBuilder<'a> { self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DeviceGroupSubmitInfoBuilder<'a> - where - T: ExtendsDeviceGroupSubmitInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceGroupSubmitInfo { self.inner } @@ -23740,14 +25998,27 @@ pub struct DeviceGroupBindSparseInfoBuilder<'a> { inner: DeviceGroupBindSparseInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupBindSparseInfo {} -unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> { type Target = DeviceGroupBindSparseInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupBindSparseInfoBuilder<'a> { pub fn resource_device_index( mut self, @@ -23763,13 +26034,6 @@ impl<'a> DeviceGroupBindSparseInfoBuilder<'a> { self.inner.memory_device_index = memory_device_index; self } - pub fn next(mut self, next: &'a T) -> DeviceGroupBindSparseInfoBuilder<'a> - where - T: ExtendsDeviceGroupBindSparseInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceGroupBindSparseInfo { self.inner } @@ -23804,13 +26068,20 @@ pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> { inner: DeviceGroupPresentCapabilitiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupPresentCapabilitiesKHR {} +pub unsafe trait ExtendsDeviceGroupPresentCapabilitiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { type Target = DeviceGroupPresentCapabilitiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { pub fn present_mask( mut self, @@ -23826,11 +26097,20 @@ impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { self.inner.modes = modes; self } - pub fn next(mut self, next: &'a T) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> - where - T: ExtendsDeviceGroupPresentCapabilitiesKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR { @@ -23865,26 +26145,32 @@ pub struct ImageSwapchainCreateInfoKHRBuilder<'a> { inner: ImageSwapchainCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageSwapchainCreateInfoKHR {} -unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> { type Target = ImageSwapchainCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> { pub fn swapchain(mut self, swapchain: SwapchainKHR) -> ImageSwapchainCreateInfoKHRBuilder<'a> { self.inner.swapchain = swapchain; self } - pub fn next(mut self, next: &'a T) -> ImageSwapchainCreateInfoKHRBuilder<'a> - where - T: ExtendsImageSwapchainCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImageSwapchainCreateInfoKHR { self.inner } @@ -23919,14 +26205,27 @@ pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> { inner: BindImageMemorySwapchainInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindImageMemorySwapchainInfoKHR {} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> { type Target = BindImageMemorySwapchainInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> { pub fn swapchain( mut self, @@ -23939,13 +26238,6 @@ impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> { self.inner.image_index = image_index; self } - pub fn next(mut self, next: &'a T) -> BindImageMemorySwapchainInfoKHRBuilder<'a> - where - T: ExtendsBindImageMemorySwapchainInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> BindImageMemorySwapchainInfoKHR { self.inner } @@ -23986,13 +26278,20 @@ pub struct AcquireNextImageInfoKHRBuilder<'a> { inner: AcquireNextImageInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAcquireNextImageInfoKHR {} +pub unsafe trait ExtendsAcquireNextImageInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> { type Target = AcquireNextImageInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AcquireNextImageInfoKHRBuilder<'a> { pub fn swapchain(mut self, swapchain: SwapchainKHR) -> AcquireNextImageInfoKHRBuilder<'a> { self.inner.swapchain = swapchain; @@ -24014,11 +26313,20 @@ impl<'a> AcquireNextImageInfoKHRBuilder<'a> { self.inner.device_mask = device_mask; self } - pub fn next(mut self, next: &'a T) -> AcquireNextImageInfoKHRBuilder<'a> - where - T: ExtendsAcquireNextImageInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> AcquireNextImageInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AcquireNextImageInfoKHR { @@ -24057,14 +26365,27 @@ pub struct DeviceGroupPresentInfoKHRBuilder<'a> { inner: DeviceGroupPresentInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupPresentInfoKHR {} -unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> { type Target = DeviceGroupPresentInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> { pub fn device_masks(mut self, device_masks: &'a [u32]) -> DeviceGroupPresentInfoKHRBuilder<'a> { self.inner.swapchain_count = device_masks.len() as _; @@ -24078,13 +26399,6 @@ impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> { self.inner.mode = mode; self } - pub fn next(mut self, next: &'a T) -> DeviceGroupPresentInfoKHRBuilder<'a> - where - T: ExtendsDeviceGroupPresentInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceGroupPresentInfoKHR { self.inner } @@ -24119,14 +26433,27 @@ pub struct DeviceGroupDeviceCreateInfoBuilder<'a> { inner: DeviceGroupDeviceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupDeviceCreateInfo {} -unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> { type Target = DeviceGroupDeviceCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> { pub fn physical_devices( mut self, @@ -24136,13 +26463,6 @@ impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> { self.inner.p_physical_devices = physical_devices.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DeviceGroupDeviceCreateInfoBuilder<'a> - where - T: ExtendsDeviceGroupDeviceCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceGroupDeviceCreateInfo { self.inner } @@ -24175,14 +26495,27 @@ pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { inner: DeviceGroupSwapchainCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupSwapchainCreateInfoKHR {} -unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { type Target = DeviceGroupSwapchainCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { pub fn modes( mut self, @@ -24191,13 +26524,6 @@ impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { self.inner.modes = modes; self } - pub fn next(mut self, next: &'a T) -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> - where - T: ExtendsDeviceGroupSwapchainCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR { self.inner } @@ -24230,6 +26556,11 @@ impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> { pub fn dst_binding(mut self, dst_binding: u32) -> DescriptorUpdateTemplateEntryBuilder<'a> { self.inner.dst_binding = dst_binding; @@ -24310,13 +26641,20 @@ pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> { inner: DescriptorUpdateTemplateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorUpdateTemplateCreateInfo {} +pub unsafe trait ExtendsDescriptorUpdateTemplateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> { type Target = DescriptorUpdateTemplateCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { pub fn flags( mut self, @@ -24365,23 +26703,20 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { self.inner.set = set; self } -<<<<<<< HEAD - pub fn next(mut self, next: &'a T) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> - where - T: ExtendsDescriptorUpdateTemplateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; -======= - pub fn next( + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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 impl ::std::ops::DerefMut, + next: &'a mut T, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { unsafe { - let ptr = &mut self.inner as *mut _ as *mut c_void; - let last_extension = ExtensionChain::last_chain(ptr); - (*last_extension).p_next = next.deref_mut() as *mut T as *mut c_void; + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; } ->>>>>>> Implement extension chaining self } pub fn build(self) -> DescriptorUpdateTemplateCreateInfo { @@ -24412,6 +26747,11 @@ impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> XYColorEXTBuilder<'a> { pub fn x(mut self, x: f32) -> XYColorEXTBuilder<'a> { self.inner.x = x; @@ -24467,13 +26807,20 @@ pub struct HdrMetadataEXTBuilder<'a> { inner: HdrMetadataEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsHdrMetadataEXT {} +pub unsafe trait ExtendsHdrMetadataEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> { type Target = HdrMetadataEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> HdrMetadataEXTBuilder<'a> { pub fn display_primary_red( mut self, @@ -24522,11 +26869,20 @@ impl<'a> HdrMetadataEXTBuilder<'a> { self.inner.max_frame_average_light_level = max_frame_average_light_level; self } - pub fn next(mut self, next: &'a T) -> HdrMetadataEXTBuilder<'a> - where - T: ExtendsHdrMetadataEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> HdrMetadataEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> HdrMetadataEXT { @@ -24556,6 +26912,11 @@ impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> { pub fn refresh_duration( mut self, @@ -24595,6 +26956,11 @@ impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PastPresentationTimingGOOGLEBuilder<'a> { pub fn present_id(mut self, present_id: u32) -> PastPresentationTimingGOOGLEBuilder<'a> { self.inner.present_id = present_id; @@ -24662,27 +27028,33 @@ pub struct PresentTimesInfoGOOGLEBuilder<'a> { inner: PresentTimesInfoGOOGLE, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPresentTimesInfoGOOGLE {} -unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> { type Target = PresentTimesInfoGOOGLE; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PresentTimesInfoGOOGLEBuilder<'a> { pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> PresentTimesInfoGOOGLEBuilder<'a> { self.inner.swapchain_count = times.len() as _; self.inner.p_times = times.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PresentTimesInfoGOOGLEBuilder<'a> - where - T: ExtendsPresentTimesInfoGOOGLE, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PresentTimesInfoGOOGLE { self.inner } @@ -24711,6 +27083,11 @@ impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PresentTimeGOOGLEBuilder<'a> { pub fn present_id(mut self, present_id: u32) -> PresentTimeGOOGLEBuilder<'a> { self.inner.present_id = present_id; @@ -24757,13 +27134,20 @@ pub struct IOSSurfaceCreateInfoMVKBuilder<'a> { inner: IOSSurfaceCreateInfoMVK, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsIOSSurfaceCreateInfoMVK {} +pub unsafe trait ExtendsIOSSurfaceCreateInfoMVK { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> { type Target = IOSSurfaceCreateInfoMVK; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> IOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.flags = flags; @@ -24773,11 +27157,20 @@ impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.p_view = view; self } - pub fn next(mut self, next: &'a T) -> IOSSurfaceCreateInfoMVKBuilder<'a> - where - T: ExtendsIOSSurfaceCreateInfoMVK, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> IOSSurfaceCreateInfoMVKBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> IOSSurfaceCreateInfoMVK { @@ -24814,13 +27207,20 @@ pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { inner: MacOSSurfaceCreateInfoMVK, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMacOSSurfaceCreateInfoMVK {} +pub unsafe trait ExtendsMacOSSurfaceCreateInfoMVK { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { type Target = MacOSSurfaceCreateInfoMVK; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { pub fn flags( mut self, @@ -24833,11 +27233,20 @@ impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.p_view = view; self } - pub fn next(mut self, next: &'a T) -> MacOSSurfaceCreateInfoMVKBuilder<'a> - where - T: ExtendsMacOSSurfaceCreateInfoMVK, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MacOSSurfaceCreateInfoMVK { @@ -24868,6 +27277,11 @@ impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ViewportWScalingNVBuilder<'a> { pub fn xcoeff(mut self, xcoeff: f32) -> ViewportWScalingNVBuilder<'a> { self.inner.xcoeff = xcoeff; @@ -24913,14 +27327,29 @@ pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { inner: PipelineViewportWScalingStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineViewportWScalingStateCreateInfoNV {} -unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportWScalingStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportWScalingStateCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { pub fn viewport_w_scaling_enable( mut self, @@ -24937,13 +27366,6 @@ impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineViewportWScalingStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV { self.inner } @@ -24974,6 +27396,11 @@ impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ViewportSwizzleNVBuilder<'a> { pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> { self.inner.x = x; @@ -25027,14 +27454,29 @@ pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { inner: PipelineViewportSwizzleStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineViewportSwizzleStateCreateInfoNV {} -unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportSwizzleStateCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { pub fn flags( mut self, @@ -25051,13 +27493,6 @@ impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineViewportSwizzleStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV { self.inner } @@ -25090,14 +27525,29 @@ pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { inner: PhysicalDeviceDiscardRectanglePropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceDiscardRectanglePropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { type Target = PhysicalDeviceDiscardRectanglePropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { pub fn max_discard_rectangles( mut self, @@ -25106,16 +27556,6 @@ impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { self.inner.max_discard_rectangles = max_discard_rectangles; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceDiscardRectanglePropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT { self.inner } @@ -25154,14 +27594,29 @@ pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { inner: PipelineDiscardRectangleStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineDiscardRectangleStateCreateInfoEXT {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { type Target = PipelineDiscardRectangleStateCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { pub fn flags( mut self, @@ -25185,13 +27640,6 @@ impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { self.inner.p_discard_rectangles = discard_rectangles.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> - where - T: ExtendsPipelineDiscardRectangleStateCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT { self.inner } @@ -25224,10 +27672,19 @@ pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; @@ -25235,6 +27692,11 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertie &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { pub fn per_view_position_all_components( mut self, @@ -25243,16 +27705,6 @@ impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { self.inner.per_view_position_all_components = per_view_position_all_components.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> - where - T: ExtendsPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { self.inner } @@ -25282,6 +27734,11 @@ impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> InputAttachmentAspectReferenceBuilder<'a> { pub fn subpass(mut self, subpass: u32) -> InputAttachmentAspectReferenceBuilder<'a> { self.inner.subpass = subpass; @@ -25335,14 +27792,27 @@ pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { inner: RenderPassInputAttachmentAspectCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassInputAttachmentAspectCreateInfo {} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { type Target = RenderPassInputAttachmentAspectCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { pub fn aspect_references( mut self, @@ -25352,13 +27822,6 @@ impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { self.inner.p_aspect_references = aspect_references.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> - where - T: ExtendsRenderPassInputAttachmentAspectCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo { self.inner } @@ -25391,23 +27854,39 @@ pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { inner: PhysicalDeviceSurfaceInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {} +pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { type Target = PhysicalDeviceSurfaceInfo2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { pub fn surface(mut self, surface: SurfaceKHR) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { self.inner.surface = surface; self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> - where - T: ExtendsPhysicalDeviceSurfaceInfo2KHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR { @@ -25442,13 +27921,20 @@ pub struct SurfaceCapabilities2KHRBuilder<'a> { inner: SurfaceCapabilities2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceCapabilities2KHR {} +pub unsafe trait ExtendsSurfaceCapabilities2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> { type Target = SurfaceCapabilities2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SurfaceCapabilities2KHRBuilder<'a> { pub fn surface_capabilities( mut self, @@ -25457,11 +27943,20 @@ impl<'a> SurfaceCapabilities2KHRBuilder<'a> { self.inner.surface_capabilities = surface_capabilities; self } - pub fn next(mut self, next: &'a mut T) -> SurfaceCapabilities2KHRBuilder<'a> - where - T: ExtendsSurfaceCapabilities2KHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SurfaceCapabilities2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SurfaceCapabilities2KHR { @@ -25496,13 +27991,20 @@ pub struct SurfaceFormat2KHRBuilder<'a> { inner: SurfaceFormat2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceFormat2KHR {} +pub unsafe trait ExtendsSurfaceFormat2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { type Target = SurfaceFormat2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SurfaceFormat2KHRBuilder<'a> { pub fn surface_format( mut self, @@ -25511,11 +28013,20 @@ impl<'a> SurfaceFormat2KHRBuilder<'a> { self.inner.surface_format = surface_format; self } - pub fn next(mut self, next: &'a mut T) -> SurfaceFormat2KHRBuilder<'a> - where - T: ExtendsSurfaceFormat2KHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SurfaceFormat2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SurfaceFormat2KHR { @@ -25550,13 +28061,20 @@ pub struct DisplayProperties2KHRBuilder<'a> { inner: DisplayProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayProperties2KHR {} +pub unsafe trait ExtendsDisplayProperties2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> { type Target = DisplayProperties2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayProperties2KHRBuilder<'a> { pub fn display_properties( mut self, @@ -25565,11 +28083,20 @@ impl<'a> DisplayProperties2KHRBuilder<'a> { self.inner.display_properties = display_properties; self } - pub fn next(mut self, next: &'a mut T) -> DisplayProperties2KHRBuilder<'a> - where - T: ExtendsDisplayProperties2KHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayProperties2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayProperties2KHR { @@ -25604,13 +28131,20 @@ pub struct DisplayPlaneProperties2KHRBuilder<'a> { inner: DisplayPlaneProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneProperties2KHR {} +pub unsafe trait ExtendsDisplayPlaneProperties2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> { type Target = DisplayPlaneProperties2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { pub fn display_plane_properties( mut self, @@ -25619,11 +28153,20 @@ impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { self.inner.display_plane_properties = display_plane_properties; self } - pub fn next(mut self, next: &'a mut T) -> DisplayPlaneProperties2KHRBuilder<'a> - where - T: ExtendsDisplayPlaneProperties2KHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayPlaneProperties2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayPlaneProperties2KHR { @@ -25658,13 +28201,20 @@ pub struct DisplayModeProperties2KHRBuilder<'a> { inner: DisplayModeProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayModeProperties2KHR {} +pub unsafe trait ExtendsDisplayModeProperties2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> { type Target = DisplayModeProperties2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayModeProperties2KHRBuilder<'a> { pub fn display_mode_properties( mut self, @@ -25673,11 +28223,20 @@ impl<'a> DisplayModeProperties2KHRBuilder<'a> { self.inner.display_mode_properties = display_mode_properties; self } - pub fn next(mut self, next: &'a mut T) -> DisplayModeProperties2KHRBuilder<'a> - where - T: ExtendsDisplayModeProperties2KHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayModeProperties2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayModeProperties2KHR { @@ -25714,13 +28273,20 @@ pub struct DisplayPlaneInfo2KHRBuilder<'a> { inner: DisplayPlaneInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneInfo2KHR {} +pub unsafe trait ExtendsDisplayPlaneInfo2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> { type Target = DisplayPlaneInfo2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { pub fn mode(mut self, mode: DisplayModeKHR) -> DisplayPlaneInfo2KHRBuilder<'a> { self.inner.mode = mode; @@ -25730,11 +28296,20 @@ impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { self.inner.plane_index = plane_index; self } - pub fn next(mut self, next: &'a T) -> DisplayPlaneInfo2KHRBuilder<'a> - where - T: ExtendsDisplayPlaneInfo2KHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayPlaneInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayPlaneInfo2KHR { @@ -25769,13 +28344,20 @@ pub struct DisplayPlaneCapabilities2KHRBuilder<'a> { inner: DisplayPlaneCapabilities2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneCapabilities2KHR {} +pub unsafe trait ExtendsDisplayPlaneCapabilities2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> { type Target = DisplayPlaneCapabilities2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { pub fn capabilities( mut self, @@ -25784,11 +28366,20 @@ impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { self.inner.capabilities = capabilities; self } - pub fn next(mut self, next: &'a mut T) -> DisplayPlaneCapabilities2KHRBuilder<'a> - where - T: ExtendsDisplayPlaneCapabilities2KHR, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DisplayPlaneCapabilities2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DisplayPlaneCapabilities2KHR { @@ -25823,14 +28414,27 @@ pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { inner: SharedPresentSurfaceCapabilitiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSharedPresentSurfaceCapabilitiesKHR {} -unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { type Target = SharedPresentSurfaceCapabilitiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { pub fn shared_present_supported_usage_flags( mut self, @@ -25839,13 +28443,6 @@ impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags; self } - pub fn next(mut self, next: &'a mut T) -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> - where - T: ExtendsSharedPresentSurfaceCapabilitiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR { self.inner } @@ -25884,15 +28481,27 @@ pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> { inner: PhysicalDevice16BitStorageFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDevice16BitStorageFeatures {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> { type Target = PhysicalDevice16BitStorageFeatures; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> { pub fn storage_buffer16_bit_access( mut self, @@ -25923,13 +28532,6 @@ impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> { self.inner.storage_input_output16 = storage_input_output16.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> - where - T: ExtendsPhysicalDevice16BitStorageFeatures, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDevice16BitStorageFeatures { self.inner } @@ -25968,14 +28570,27 @@ pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> { inner: PhysicalDeviceSubgroupProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSubgroupProperties {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> { type Target = PhysicalDeviceSubgroupProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> { pub fn subgroup_size( mut self, @@ -26005,13 +28620,6 @@ impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> { self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> - where - T: ExtendsPhysicalDeviceSubgroupProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceSubgroupProperties { self.inner } @@ -26044,23 +28652,39 @@ pub struct BufferMemoryRequirementsInfo2Builder<'a> { inner: BufferMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferMemoryRequirementsInfo2 {} +pub unsafe trait ExtendsBufferMemoryRequirementsInfo2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> { type Target = BufferMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { pub fn buffer(mut self, buffer: Buffer) -> BufferMemoryRequirementsInfo2Builder<'a> { self.inner.buffer = buffer; self } - pub fn next(mut self, next: &'a T) -> BufferMemoryRequirementsInfo2Builder<'a> - where - T: ExtendsBufferMemoryRequirementsInfo2, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BufferMemoryRequirementsInfo2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BufferMemoryRequirementsInfo2 { @@ -26095,23 +28719,39 @@ pub struct ImageMemoryRequirementsInfo2Builder<'a> { inner: ImageMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {} +pub unsafe trait ExtendsImageMemoryRequirementsInfo2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> { type Target = ImageMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { pub fn image(mut self, image: Image) -> ImageMemoryRequirementsInfo2Builder<'a> { self.inner.image = image; self } - pub fn next(mut self, next: &'a T) -> ImageMemoryRequirementsInfo2Builder<'a> - where - T: ExtendsImageMemoryRequirementsInfo2, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImageMemoryRequirementsInfo2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImageMemoryRequirementsInfo2 { @@ -26146,23 +28786,39 @@ pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> { inner: ImageSparseMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageSparseMemoryRequirementsInfo2 {} +pub unsafe trait ExtendsImageSparseMemoryRequirementsInfo2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> { type Target = ImageSparseMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { pub fn image(mut self, image: Image) -> ImageSparseMemoryRequirementsInfo2Builder<'a> { self.inner.image = image; self } - pub fn next(mut self, next: &'a T) -> ImageSparseMemoryRequirementsInfo2Builder<'a> - where - T: ExtendsImageSparseMemoryRequirementsInfo2, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImageSparseMemoryRequirementsInfo2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 { @@ -26197,13 +28853,20 @@ pub struct MemoryRequirements2Builder<'a> { inner: MemoryRequirements2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryRequirements2 {} +pub unsafe trait ExtendsMemoryRequirements2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> { type Target = MemoryRequirements2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryRequirements2Builder<'a> { pub fn memory_requirements( mut self, @@ -26212,11 +28875,20 @@ impl<'a> MemoryRequirements2Builder<'a> { self.inner.memory_requirements = memory_requirements; self } - pub fn next(mut self, next: &'a mut T) -> MemoryRequirements2Builder<'a> - where - T: ExtendsMemoryRequirements2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryRequirements2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryRequirements2 { @@ -26251,13 +28923,20 @@ pub struct SparseImageMemoryRequirements2Builder<'a> { inner: SparseImageMemoryRequirements2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSparseImageMemoryRequirements2 {} +pub unsafe trait ExtendsSparseImageMemoryRequirements2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> { type Target = SparseImageMemoryRequirements2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SparseImageMemoryRequirements2Builder<'a> { pub fn memory_requirements( mut self, @@ -26266,11 +28945,20 @@ impl<'a> SparseImageMemoryRequirements2Builder<'a> { self.inner.memory_requirements = memory_requirements; self } - pub fn next(mut self, next: &'a mut T) -> SparseImageMemoryRequirements2Builder<'a> - where - T: ExtendsSparseImageMemoryRequirements2, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SparseImageMemoryRequirements2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SparseImageMemoryRequirements2 { @@ -26305,14 +28993,27 @@ pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> { inner: PhysicalDevicePointClippingProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDevicePointClippingProperties {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> { type Target = PhysicalDevicePointClippingProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> { pub fn point_clipping_behavior( mut self, @@ -26321,13 +29022,6 @@ impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> { self.inner.point_clipping_behavior = point_clipping_behavior; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDevicePointClippingPropertiesBuilder<'a> - where - T: ExtendsPhysicalDevicePointClippingProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDevicePointClippingProperties { self.inner } @@ -26362,14 +29056,27 @@ pub struct MemoryDedicatedRequirementsBuilder<'a> { inner: MemoryDedicatedRequirements, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryDedicatedRequirements {} -unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> { type Target = MemoryDedicatedRequirements; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryDedicatedRequirementsBuilder<'a> { pub fn prefers_dedicated_allocation( mut self, @@ -26385,13 +29092,6 @@ impl<'a> MemoryDedicatedRequirementsBuilder<'a> { self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into(); self } - pub fn next(mut self, next: &'a mut T) -> MemoryDedicatedRequirementsBuilder<'a> - where - T: ExtendsMemoryDedicatedRequirements, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> MemoryDedicatedRequirements { self.inner } @@ -26426,14 +29126,27 @@ pub struct MemoryDedicatedAllocateInfoBuilder<'a> { inner: MemoryDedicatedAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryDedicatedAllocateInfo {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> { type Target = MemoryDedicatedAllocateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> { pub fn image(mut self, image: Image) -> MemoryDedicatedAllocateInfoBuilder<'a> { self.inner.image = image; @@ -26443,13 +29156,6 @@ impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> { self.inner.buffer = buffer; self } - pub fn next(mut self, next: &'a T) -> MemoryDedicatedAllocateInfoBuilder<'a> - where - T: ExtendsMemoryDedicatedAllocateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> MemoryDedicatedAllocateInfo { self.inner } @@ -26482,26 +29188,32 @@ pub struct ImageViewUsageCreateInfoBuilder<'a> { inner: ImageViewUsageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageViewUsageCreateInfo {} -unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> { type Target = ImageViewUsageCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageViewUsageCreateInfoBuilder<'a> { pub fn usage(mut self, usage: ImageUsageFlags) -> ImageViewUsageCreateInfoBuilder<'a> { self.inner.usage = usage; self } - pub fn next(mut self, next: &'a T) -> ImageViewUsageCreateInfoBuilder<'a> - where - T: ExtendsImageViewUsageCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImageViewUsageCreateInfo { self.inner } @@ -26534,10 +29246,19 @@ pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { inner: PipelineTessellationDomainOriginStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineTessellationDomainOriginStateCreateInfo {} +unsafe impl ExtendsPipelineTessellationStateCreateInfo + for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineTessellationStateCreateInfo for PipelineTessellationDomainOriginStateCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { type Target = PipelineTessellationDomainOriginStateCreateInfo; @@ -26545,6 +29266,11 @@ impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBu &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { pub fn domain_origin( mut self, @@ -26553,16 +29279,6 @@ impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { self.inner.domain_origin = domain_origin; self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> - where - T: ExtendsPipelineTessellationDomainOriginStateCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo { self.inner } @@ -26595,15 +29311,27 @@ pub struct SamplerYcbcrConversionInfoBuilder<'a> { inner: SamplerYcbcrConversionInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSamplerYcbcrConversionInfo {} -unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {} -unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> { type Target = SamplerYcbcrConversionInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SamplerYcbcrConversionInfoBuilder<'a> { pub fn conversion( mut self, @@ -26612,13 +29340,6 @@ impl<'a> SamplerYcbcrConversionInfoBuilder<'a> { self.inner.conversion = conversion; self } - pub fn next(mut self, next: &'a T) -> SamplerYcbcrConversionInfoBuilder<'a> - where - T: ExtendsSamplerYcbcrConversionInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> SamplerYcbcrConversionInfo { self.inner } @@ -26665,13 +29386,20 @@ pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> { inner: SamplerYcbcrConversionCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {} +pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> { type Target = SamplerYcbcrConversionCreateInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { pub fn format(mut self, format: Format) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { self.inner.format = format; @@ -26726,11 +29454,20 @@ impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into(); self } - pub fn next(mut self, next: &'a T) -> SamplerYcbcrConversionCreateInfoBuilder<'a> - where - T: ExtendsSamplerYcbcrConversionCreateInfo, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SamplerYcbcrConversionCreateInfo { @@ -26765,14 +29502,27 @@ pub struct BindImagePlaneMemoryInfoBuilder<'a> { inner: BindImagePlaneMemoryInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindImagePlaneMemoryInfo {} -unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> { type Target = BindImagePlaneMemoryInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindImagePlaneMemoryInfoBuilder<'a> { pub fn plane_aspect( mut self, @@ -26781,13 +29531,6 @@ impl<'a> BindImagePlaneMemoryInfoBuilder<'a> { self.inner.plane_aspect = plane_aspect; self } - pub fn next(mut self, next: &'a T) -> BindImagePlaneMemoryInfoBuilder<'a> - where - T: ExtendsBindImagePlaneMemoryInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> BindImagePlaneMemoryInfo { self.inner } @@ -26820,14 +29563,27 @@ pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> { inner: ImagePlaneMemoryRequirementsInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImagePlaneMemoryRequirementsInfo {} -unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> { type Target = ImagePlaneMemoryRequirementsInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> { pub fn plane_aspect( mut self, @@ -26836,13 +29592,6 @@ impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> { self.inner.plane_aspect = plane_aspect; self } - pub fn next(mut self, next: &'a T) -> ImagePlaneMemoryRequirementsInfoBuilder<'a> - where - T: ExtendsImagePlaneMemoryRequirementsInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImagePlaneMemoryRequirementsInfo { self.inner } @@ -26875,15 +29624,27 @@ pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { inner: PhysicalDeviceSamplerYcbcrConversionFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSamplerYcbcrConversionFeatures {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { type Target = PhysicalDeviceSamplerYcbcrConversionFeatures; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { pub fn sampler_ycbcr_conversion( mut self, @@ -26892,16 +29653,6 @@ impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> - where - T: ExtendsPhysicalDeviceSamplerYcbcrConversionFeatures, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures { self.inner } @@ -26934,14 +29685,29 @@ pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { inner: SamplerYcbcrConversionImageFormatProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSamplerYcbcrConversionImageFormatProperties {} -unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {} +unsafe impl ExtendsImageFormatProperties2 + for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { type Target = SamplerYcbcrConversionImageFormatProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { pub fn combined_image_sampler_descriptor_count( mut self, @@ -26951,16 +29717,6 @@ impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { combined_image_sampler_descriptor_count; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> - where - T: ExtendsSamplerYcbcrConversionImageFormatProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties { self.inner } @@ -26993,14 +29749,27 @@ pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> { inner: TextureLODGatherFormatPropertiesAMD, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsTextureLODGatherFormatPropertiesAMD {} -unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> { type Target = TextureLODGatherFormatPropertiesAMD; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> { pub fn supports_texture_gather_lod_bias_amd( mut self, @@ -27010,13 +29779,6 @@ impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> { supports_texture_gather_lod_bias_amd.into(); self } - pub fn next(mut self, next: &'a mut T) -> TextureLODGatherFormatPropertiesAMDBuilder<'a> - where - T: ExtendsTextureLODGatherFormatPropertiesAMD, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> TextureLODGatherFormatPropertiesAMD { self.inner } @@ -27053,13 +29815,20 @@ pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> { inner: ConditionalRenderingBeginInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsConditionalRenderingBeginInfoEXT {} +pub unsafe trait ExtendsConditionalRenderingBeginInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> { type Target = ConditionalRenderingBeginInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { pub fn buffer(mut self, buffer: Buffer) -> ConditionalRenderingBeginInfoEXTBuilder<'a> { self.inner.buffer = buffer; @@ -27076,11 +29845,20 @@ impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { self.inner.flags = flags; self } - pub fn next(mut self, next: &'a T) -> ConditionalRenderingBeginInfoEXTBuilder<'a> - where - T: ExtendsConditionalRenderingBeginInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ConditionalRenderingBeginInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ConditionalRenderingBeginInfoEXT { @@ -27115,26 +29893,32 @@ pub struct ProtectedSubmitInfoBuilder<'a> { inner: ProtectedSubmitInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsProtectedSubmitInfo {} -unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> { type Target = ProtectedSubmitInfo; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ProtectedSubmitInfoBuilder<'a> { pub fn protected_submit(mut self, protected_submit: bool) -> ProtectedSubmitInfoBuilder<'a> { self.inner.protected_submit = protected_submit.into(); self } - pub fn next(mut self, next: &'a T) -> ProtectedSubmitInfoBuilder<'a> - where - T: ExtendsProtectedSubmitInfo, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ProtectedSubmitInfo { self.inner } @@ -27167,15 +29951,27 @@ pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { inner: PhysicalDeviceProtectedMemoryFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceProtectedMemoryFeatures {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { type Target = PhysicalDeviceProtectedMemoryFeatures; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { pub fn protected_memory( mut self, @@ -27184,13 +29980,6 @@ impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { self.inner.protected_memory = protected_memory.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> - where - T: ExtendsPhysicalDeviceProtectedMemoryFeatures, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures { self.inner } @@ -27223,14 +30012,29 @@ pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { inner: PhysicalDeviceProtectedMemoryProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceProtectedMemoryProperties {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { type Target = PhysicalDeviceProtectedMemoryProperties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { pub fn protected_no_fault( mut self, @@ -27239,13 +30043,6 @@ impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { self.inner.protected_no_fault = protected_no_fault.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> - where - T: ExtendsPhysicalDeviceProtectedMemoryProperties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties { self.inner } @@ -27282,13 +30079,20 @@ pub struct DeviceQueueInfo2Builder<'a> { inner: DeviceQueueInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceQueueInfo2 {} +pub unsafe trait ExtendsDeviceQueueInfo2 { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> { type Target = DeviceQueueInfo2; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceQueueInfo2Builder<'a> { pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueInfo2Builder<'a> { self.inner.flags = flags; @@ -27302,11 +30106,20 @@ impl<'a> DeviceQueueInfo2Builder<'a> { self.inner.queue_index = queue_index; self } - pub fn next(mut self, next: &'a T) -> DeviceQueueInfo2Builder<'a> - where - T: ExtendsDeviceQueueInfo2, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DeviceQueueInfo2Builder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DeviceQueueInfo2 { @@ -27345,14 +30158,29 @@ pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { inner: PipelineCoverageToColorStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineCoverageToColorStateCreateInfoNV {} -unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageToColorStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { type Target = PipelineCoverageToColorStateCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { pub fn flags( mut self, @@ -27375,13 +30203,6 @@ impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { self.inner.coverage_to_color_location = coverage_to_color_location; self } - pub fn next(mut self, next: &'a T) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineCoverageToColorStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV { self.inner } @@ -27416,14 +30237,29 @@ pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { inner: PhysicalDeviceSamplerFilterMinmaxPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceSamplerFilterMinmaxPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { pub fn filter_minmax_single_component_formats( mut self, @@ -27441,16 +30277,6 @@ impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { filter_minmax_image_component_mapping.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { self.inner } @@ -27479,6 +30305,11 @@ impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SampleLocationEXTBuilder<'a> { pub fn x(mut self, x: f32) -> SampleLocationEXTBuilder<'a> { self.inner.x = x; @@ -27526,14 +30357,27 @@ pub struct SampleLocationsInfoEXTBuilder<'a> { inner: SampleLocationsInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSampleLocationsInfoEXT {} -unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> { type Target = SampleLocationsInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SampleLocationsInfoEXTBuilder<'a> { pub fn sample_locations_per_pixel( mut self, @@ -27557,13 +30401,6 @@ impl<'a> SampleLocationsInfoEXTBuilder<'a> { self.inner.p_sample_locations = sample_locations.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> SampleLocationsInfoEXTBuilder<'a> - where - T: ExtendsSampleLocationsInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> SampleLocationsInfoEXT { self.inner } @@ -27592,6 +30429,11 @@ impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AttachmentSampleLocationsEXTBuilder<'a> { pub fn attachment_index( mut self, @@ -27635,6 +30477,11 @@ impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassSampleLocationsEXTBuilder<'a> { pub fn subpass_index(mut self, subpass_index: u32) -> SubpassSampleLocationsEXTBuilder<'a> { self.inner.subpass_index = subpass_index; @@ -27685,14 +30532,27 @@ pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { inner: RenderPassSampleLocationsBeginInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassSampleLocationsBeginInfoEXT {} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { type Target = RenderPassSampleLocationsBeginInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { pub fn attachment_initial_sample_locations( mut self, @@ -27712,13 +30572,6 @@ impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> - where - T: ExtendsRenderPassSampleLocationsBeginInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT { self.inner } @@ -27753,10 +30606,19 @@ pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { inner: PipelineSampleLocationsStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineSampleLocationsStateCreateInfoEXT {} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineSampleLocationsStateCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { type Target = PipelineSampleLocationsStateCreateInfoEXT; @@ -27764,6 +30626,11 @@ impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder< &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { pub fn sample_locations_enable( mut self, @@ -27779,13 +30646,6 @@ impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { self.inner.sample_locations_info = sample_locations_info; self } - pub fn next(mut self, next: &'a T) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> - where - T: ExtendsPipelineSampleLocationsStateCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT { self.inner } @@ -27826,14 +30686,29 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { inner: PhysicalDeviceSampleLocationsPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSampleLocationsPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceSampleLocationsPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { pub fn sample_location_sample_counts( mut self, @@ -27870,16 +30745,6 @@ impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { self.inner.variable_sample_locations = variable_sample_locations.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceSampleLocationsPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT { self.inner } @@ -27912,13 +30777,20 @@ pub struct MultisamplePropertiesEXTBuilder<'a> { inner: MultisamplePropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMultisamplePropertiesEXT {} +pub unsafe trait ExtendsMultisamplePropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> { type Target = MultisamplePropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MultisamplePropertiesEXTBuilder<'a> { pub fn max_sample_location_grid_size( mut self, @@ -27927,11 +30799,20 @@ impl<'a> MultisamplePropertiesEXTBuilder<'a> { self.inner.max_sample_location_grid_size = max_sample_location_grid_size; self } - pub fn next(mut self, next: &'a mut T) -> MultisamplePropertiesEXTBuilder<'a> - where - T: ExtendsMultisamplePropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MultisamplePropertiesEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MultisamplePropertiesEXT { @@ -27966,14 +30847,27 @@ pub struct SamplerReductionModeCreateInfoEXTBuilder<'a> { inner: SamplerReductionModeCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSamplerReductionModeCreateInfoEXT {} -unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoEXT {} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoEXTBuilder<'a> { type Target = SamplerReductionModeCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SamplerReductionModeCreateInfoEXTBuilder<'a> { pub fn reduction_mode( mut self, @@ -27982,13 +30876,6 @@ impl<'a> SamplerReductionModeCreateInfoEXTBuilder<'a> { self.inner.reduction_mode = reduction_mode; self } - pub fn next(mut self, next: &'a T) -> SamplerReductionModeCreateInfoEXTBuilder<'a> - where - T: ExtendsSamplerReductionModeCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> SamplerReductionModeCreateInfoEXT { self.inner } @@ -28021,15 +30908,27 @@ pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceBlendOperationAdvancedFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { pub fn advanced_blend_coherent_operations( mut self, @@ -28038,16 +30937,6 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceBlendOperationAdvancedFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT { self.inner } @@ -28090,14 +30979,29 @@ pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceBlendOperationAdvancedPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { pub fn advanced_blend_max_color_attachments( mut self, @@ -28143,16 +31047,6 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceBlendOperationAdvancedPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT { self.inner } @@ -28189,10 +31083,19 @@ pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { inner: PipelineColorBlendAdvancedStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineColorBlendAdvancedStateCreateInfoEXT {} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo + for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorBlendAdvancedStateCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { type Target = PipelineColorBlendAdvancedStateCreateInfoEXT; @@ -28200,6 +31103,11 @@ impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuild &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { pub fn src_premultiplied( mut self, @@ -28222,13 +31130,6 @@ impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { self.inner.blend_overlap = blend_overlap; self } - pub fn next(mut self, next: &'a T) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> - where - T: ExtendsPipelineColorBlendAdvancedStateCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT { self.inner } @@ -28263,15 +31164,27 @@ pub struct PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { inner: PhysicalDeviceInlineUniformBlockFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceInlineUniformBlockFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceInlineUniformBlockFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { pub fn inline_uniform_block( mut self, @@ -28289,16 +31202,6 @@ impl<'a> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { descriptor_binding_inline_uniform_block_update_after_bind.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceInlineUniformBlockFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeaturesEXT { self.inner } @@ -28339,14 +31242,29 @@ pub struct PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { inner: PhysicalDeviceInlineUniformBlockPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceInlineUniformBlockPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceInlineUniformBlockPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { pub fn max_inline_uniform_block_size( mut self, @@ -28389,16 +31307,6 @@ impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { max_descriptor_set_update_after_bind_inline_uniform_blocks; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceInlineUniformBlockPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceInlineUniformBlockPropertiesEXT { self.inner } @@ -28433,27 +31341,33 @@ pub struct WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> { inner: WriteDescriptorSetInlineUniformBlockEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWriteDescriptorSetInlineUniformBlockEXT {} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXT {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> { type Target = WriteDescriptorSetInlineUniformBlockEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> { pub fn data(mut self, data: &'a [u8]) -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> { self.inner.data_size = data.len() as _; self.inner.p_data = data.as_ptr() as *const c_void; self } - pub fn next(mut self, next: &'a T) -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> - where - T: ExtendsWriteDescriptorSetInlineUniformBlockEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> WriteDescriptorSetInlineUniformBlockEXT { self.inner } @@ -28486,14 +31400,29 @@ pub struct DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { inner: DescriptorPoolInlineUniformBlockCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorPoolInlineUniformBlockCreateInfoEXT {} -unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXT {} +unsafe impl ExtendsDescriptorPoolCreateInfo + for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { type Target = DescriptorPoolInlineUniformBlockCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { pub fn max_inline_uniform_block_bindings( mut self, @@ -28502,16 +31431,6 @@ impl<'a> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings; self } - pub fn next( - mut self, - next: &'a T, - ) -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> - where - T: ExtendsDescriptorPoolInlineUniformBlockCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfoEXT { self.inner } @@ -28552,10 +31471,19 @@ pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { inner: PipelineCoverageModulationStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineCoverageModulationStateCreateInfoNV {} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageModulationStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageModulationStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { type Target = PipelineCoverageModulationStateCreateInfoNV; @@ -28563,6 +31491,11 @@ impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilde &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { pub fn flags( mut self, @@ -28593,13 +31526,6 @@ impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineCoverageModulationStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV { self.inner } @@ -28634,16 +31560,27 @@ pub struct ImageFormatListCreateInfoKHRBuilder<'a> { inner: ImageFormatListCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageFormatListCreateInfoKHR {} -unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHR {} -unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoKHR {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoKHR {} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoKHRBuilder<'a> { type Target = ImageFormatListCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageFormatListCreateInfoKHRBuilder<'a> { pub fn view_formats( mut self, @@ -28653,13 +31590,6 @@ impl<'a> ImageFormatListCreateInfoKHRBuilder<'a> { self.inner.p_view_formats = view_formats.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> ImageFormatListCreateInfoKHRBuilder<'a> - where - T: ExtendsImageFormatListCreateInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImageFormatListCreateInfoKHR { self.inner } @@ -28696,13 +31626,20 @@ pub struct ValidationCacheCreateInfoEXTBuilder<'a> { inner: ValidationCacheCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsValidationCacheCreateInfoEXT {} +pub unsafe trait ExtendsValidationCacheCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> { type Target = ValidationCacheCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { pub fn flags( mut self, @@ -28719,11 +31656,20 @@ impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { self.inner.p_initial_data = initial_data.as_ptr() as *const c_void; self } - pub fn next(mut self, next: &'a T) -> ValidationCacheCreateInfoEXTBuilder<'a> - where - T: ExtendsValidationCacheCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ValidationCacheCreateInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ValidationCacheCreateInfoEXT { @@ -28758,14 +31704,27 @@ pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { inner: ShaderModuleValidationCacheCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsShaderModuleValidationCacheCreateInfoEXT {} -unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { type Target = ShaderModuleValidationCacheCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { pub fn validation_cache( mut self, @@ -28774,13 +31733,6 @@ impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { self.inner.validation_cache = validation_cache; self } - pub fn next(mut self, next: &'a T) -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> - where - T: ExtendsShaderModuleValidationCacheCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT { self.inner } @@ -28815,14 +31767,27 @@ pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> { inner: PhysicalDeviceMaintenance3Properties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMaintenance3Properties {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { type Target = PhysicalDeviceMaintenance3Properties; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { pub fn max_per_set_descriptors( mut self, @@ -28838,13 +31803,6 @@ impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { self.inner.max_memory_allocation_size = max_memory_allocation_size; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> - where - T: ExtendsPhysicalDeviceMaintenance3Properties, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMaintenance3Properties { self.inner } @@ -28877,23 +31835,39 @@ pub struct DescriptorSetLayoutSupportBuilder<'a> { inner: DescriptorSetLayoutSupport, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetLayoutSupport {} +pub unsafe trait ExtendsDescriptorSetLayoutSupport { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> { type Target = DescriptorSetLayoutSupport; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorSetLayoutSupportBuilder<'a> { pub fn supported(mut self, supported: bool) -> DescriptorSetLayoutSupportBuilder<'a> { self.inner.supported = supported.into(); self } - pub fn next(mut self, next: &'a mut T) -> DescriptorSetLayoutSupportBuilder<'a> - where - T: ExtendsDescriptorSetLayoutSupport, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DescriptorSetLayoutSupportBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DescriptorSetLayoutSupport { @@ -28928,15 +31902,27 @@ pub struct PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { inner: PhysicalDeviceShaderDrawParameterFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceShaderDrawParameterFeatures {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParameterFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParameterFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParameterFeaturesBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParameterFeatures { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { type Target = PhysicalDeviceShaderDrawParameterFeatures; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { pub fn shader_draw_parameters( mut self, @@ -28945,16 +31931,6 @@ impl<'a> PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { self.inner.shader_draw_parameters = shader_draw_parameters.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> - where - T: ExtendsPhysicalDeviceShaderDrawParameterFeatures, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceShaderDrawParameterFeatures { self.inner } @@ -28989,15 +31965,27 @@ pub struct PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> { inner: PhysicalDeviceFloat16Int8FeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceFloat16Int8FeaturesKHR {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFloat16Int8FeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFloat16Int8FeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFloat16Int8FeaturesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> { type Target = PhysicalDeviceFloat16Int8FeaturesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> { pub fn shader_float16( mut self, @@ -29013,13 +32001,6 @@ impl<'a> PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> { self.inner.shader_int8 = shader_int8.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> - where - T: ExtendsPhysicalDeviceFloat16Int8FeaturesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceFloat16Int8FeaturesKHR { self.inner } @@ -29084,14 +32065,29 @@ pub struct PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { inner: PhysicalDeviceFloatControlsPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceFloatControlsPropertiesKHR {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesKHR {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFloatControlsPropertiesKHRBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { type Target = PhysicalDeviceFloatControlsPropertiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { pub fn separate_denorm_settings( mut self, @@ -29215,13 +32211,6 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> - where - T: ExtendsPhysicalDeviceFloatControlsPropertiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceFloatControlsPropertiesKHR { self.inner } @@ -29260,13 +32249,20 @@ pub struct NativeBufferANDROIDBuilder<'a> { inner: NativeBufferANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsNativeBufferANDROID {} +pub unsafe trait ExtendsNativeBufferANDROID { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> { type Target = NativeBufferANDROID; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> NativeBufferANDROIDBuilder<'a> { pub fn handle(mut self, handle: *const c_void) -> NativeBufferANDROIDBuilder<'a> { self.inner.handle = handle; @@ -29284,11 +32280,20 @@ impl<'a> NativeBufferANDROIDBuilder<'a> { self.inner.usage = usage; self } - pub fn next(mut self, next: &'a T) -> NativeBufferANDROIDBuilder<'a> - where - T: ExtendsNativeBufferANDROID, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> NativeBufferANDROIDBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> NativeBufferANDROID { @@ -29322,6 +32327,11 @@ impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ShaderResourceUsageAMDBuilder<'a> { pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> ShaderResourceUsageAMDBuilder<'a> { self.inner.num_used_vgprs = num_used_vgprs; @@ -29398,6 +32408,11 @@ impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ShaderStatisticsInfoAMDBuilder<'a> { pub fn shader_stage_mask( mut self, @@ -29480,14 +32495,27 @@ pub struct DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { inner: DeviceQueueGlobalPriorityCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceQueueGlobalPriorityCreateInfoEXT {} -unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXT {} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { type Target = DeviceQueueGlobalPriorityCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { pub fn global_priority( mut self, @@ -29496,13 +32524,6 @@ impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { self.inner.global_priority = global_priority; self } - pub fn next(mut self, next: &'a T) -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> - where - T: ExtendsDeviceQueueGlobalPriorityCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoEXT { self.inner } @@ -29539,13 +32560,20 @@ pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> { inner: DebugUtilsObjectNameInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsObjectNameInfoEXT {} +pub unsafe trait ExtendsDebugUtilsObjectNameInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> { type Target = DebugUtilsObjectNameInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { pub fn object_type( mut self, @@ -29565,11 +32593,20 @@ impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { self.inner.p_object_name = object_name.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DebugUtilsObjectNameInfoEXTBuilder<'a> - where - T: ExtendsDebugUtilsObjectNameInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DebugUtilsObjectNameInfoEXT { @@ -29612,13 +32649,20 @@ pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> { inner: DebugUtilsObjectTagInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsObjectTagInfoEXT {} +pub unsafe trait ExtendsDebugUtilsObjectTagInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> { type Target = DebugUtilsObjectTagInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { pub fn object_type(mut self, object_type: ObjectType) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { self.inner.object_type = object_type; @@ -29637,11 +32681,20 @@ impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { self.inner.p_tag = tag.as_ptr() as *const c_void; self } - pub fn next(mut self, next: &'a T) -> DebugUtilsObjectTagInfoEXTBuilder<'a> - where - T: ExtendsDebugUtilsObjectTagInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DebugUtilsObjectTagInfoEXT { @@ -29678,13 +32731,20 @@ pub struct DebugUtilsLabelEXTBuilder<'a> { inner: DebugUtilsLabelEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsLabelEXT {} +pub unsafe trait ExtendsDebugUtilsLabelEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> { type Target = DebugUtilsLabelEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugUtilsLabelEXTBuilder<'a> { pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> DebugUtilsLabelEXTBuilder<'a> { self.inner.p_label_name = label_name.as_ptr(); @@ -29694,11 +32754,20 @@ impl<'a> DebugUtilsLabelEXTBuilder<'a> { self.inner.color = color; self } - pub fn next(mut self, next: &'a T) -> DebugUtilsLabelEXTBuilder<'a> - where - T: ExtendsDebugUtilsLabelEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DebugUtilsLabelEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DebugUtilsLabelEXT { @@ -29757,14 +32826,27 @@ pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> { inner: DebugUtilsMessengerCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsMessengerCreateInfoEXT {} -unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { type Target = DebugUtilsMessengerCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { pub fn flags( mut self, @@ -29801,13 +32883,6 @@ impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { self.inner.p_user_data = user_data; self } - pub fn next(mut self, next: &'a T) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> - where - T: ExtendsDebugUtilsMessengerCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT { self.inner } @@ -29858,13 +32933,20 @@ pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> { inner: DebugUtilsMessengerCallbackDataEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {} +pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { type Target = DebugUtilsMessengerCallbackDataEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { pub fn flags( mut self, @@ -29918,11 +33000,20 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { self.inner.p_objects = objects.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> - where - T: ExtendsDebugUtilsMessengerCallbackDataEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT { @@ -29959,14 +33050,27 @@ pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> { inner: ImportMemoryHostPointerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportMemoryHostPointerInfoEXT {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> { type Target = ImportMemoryHostPointerInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> { pub fn handle_type( mut self, @@ -29982,13 +33086,6 @@ impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> { self.inner.p_host_pointer = host_pointer; self } - pub fn next(mut self, next: &'a T) -> ImportMemoryHostPointerInfoEXTBuilder<'a> - where - T: ExtendsImportMemoryHostPointerInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImportMemoryHostPointerInfoEXT { self.inner } @@ -30021,13 +33118,20 @@ pub struct MemoryHostPointerPropertiesEXTBuilder<'a> { inner: MemoryHostPointerPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryHostPointerPropertiesEXT {} +pub unsafe trait ExtendsMemoryHostPointerPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> { type Target = MemoryHostPointerPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { pub fn memory_type_bits( mut self, @@ -30036,11 +33140,20 @@ impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - pub fn next(mut self, next: &'a mut T) -> MemoryHostPointerPropertiesEXTBuilder<'a> - where - T: ExtendsMemoryHostPointerPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryHostPointerPropertiesEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryHostPointerPropertiesEXT { @@ -30075,14 +33188,29 @@ pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { inner: PhysicalDeviceExternalMemoryHostPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalMemoryHostPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { pub fn min_imported_host_pointer_alignment( mut self, @@ -30091,16 +33219,6 @@ impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceExternalMemoryHostPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT { self.inner } @@ -30149,10 +33267,19 @@ pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { inner: PhysicalDeviceConservativeRasterizationPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceConservativeRasterizationPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceConservativeRasterizationPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT; @@ -30160,6 +33287,11 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationProperties &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { pub fn primitive_overestimation_size( mut self, @@ -30229,16 +33361,6 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { conservative_rasterization_post_depth_coverage.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceConservativeRasterizationPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT { self.inner } @@ -30271,13 +33393,20 @@ pub struct CalibratedTimestampInfoEXTBuilder<'a> { inner: CalibratedTimestampInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCalibratedTimestampInfoEXT {} +pub unsafe trait ExtendsCalibratedTimestampInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> { type Target = CalibratedTimestampInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { pub fn time_domain( mut self, @@ -30286,11 +33415,20 @@ impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { self.inner.time_domain = time_domain; self } - pub fn next(mut self, next: &'a T) -> CalibratedTimestampInfoEXTBuilder<'a> - where - T: ExtendsCalibratedTimestampInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CalibratedTimestampInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CalibratedTimestampInfoEXT { @@ -30351,14 +33489,27 @@ pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { inner: PhysicalDeviceShaderCorePropertiesAMD, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceShaderCorePropertiesAMD {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { type Target = PhysicalDeviceShaderCorePropertiesAMD; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { pub fn shader_engine_count( mut self, @@ -30458,13 +33609,6 @@ impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> - where - T: ExtendsPhysicalDeviceShaderCorePropertiesAMD, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD { self.inner } @@ -30501,10 +33645,19 @@ pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { inner: PipelineRasterizationConservativeStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineRasterizationConservativeStateCreateInfoEXT {} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationConservativeStateCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { type Target = PipelineRasterizationConservativeStateCreateInfoEXT; @@ -30512,6 +33665,11 @@ impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoE &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { pub fn flags( mut self, @@ -30534,16 +33692,6 @@ impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size; self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> - where - T: ExtendsPipelineRasterizationConservativeStateCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT { self.inner } @@ -30614,15 +33762,27 @@ pub struct PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { inner: PhysicalDeviceDescriptorIndexingFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceDescriptorIndexingFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceDescriptorIndexingFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { pub fn shader_input_attachment_array_dynamic_indexing( mut self, @@ -30793,16 +33953,6 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { self.inner.runtime_descriptor_array = runtime_descriptor_array.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceDescriptorIndexingFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeaturesEXT { self.inner } @@ -30879,14 +34029,29 @@ pub struct PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { inner: PhysicalDeviceDescriptorIndexingPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceDescriptorIndexingPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceDescriptorIndexingPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { pub fn max_update_after_bind_descriptors_in_all_pools( mut self, @@ -31089,16 +34254,6 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { max_descriptor_set_update_after_bind_input_attachments; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceDescriptorIndexingPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceDescriptorIndexingPropertiesEXT { self.inner } @@ -31133,14 +34288,29 @@ pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { inner: DescriptorSetLayoutBindingFlagsCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetLayoutBindingFlagsCreateInfoEXT {} -unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfoEXT {} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo + for DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { type Target = DescriptorSetLayoutBindingFlagsCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { pub fn binding_flags( mut self, @@ -31150,13 +34320,6 @@ impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { self.inner.p_binding_flags = binding_flags.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> - where - T: ExtendsDescriptorSetLayoutBindingFlagsCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfoEXT { self.inner } @@ -31191,10 +34354,19 @@ pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { inner: DescriptorSetVariableDescriptorCountAllocateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetVariableDescriptorCountAllocateInfoEXT {} +unsafe impl ExtendsDescriptorSetAllocateInfo + for DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { type Target = DescriptorSetVariableDescriptorCountAllocateInfoEXT; @@ -31202,6 +34374,11 @@ impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoE &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { pub fn descriptor_counts( mut self, @@ -31211,16 +34388,6 @@ impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { self.inner.p_descriptor_counts = descriptor_counts.as_ptr(); self } - pub fn next( - mut self, - next: &'a T, - ) -> DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> - where - T: ExtendsDescriptorSetVariableDescriptorCountAllocateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfoEXT { self.inner } @@ -31253,10 +34420,19 @@ pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { inner: DescriptorSetVariableDescriptorCountLayoutSupportEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetVariableDescriptorCountLayoutSupportEXT {} +unsafe impl ExtendsDescriptorSetLayoutSupport + for DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsDescriptorSetLayoutSupport for DescriptorSetVariableDescriptorCountLayoutSupportEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { type Target = DescriptorSetVariableDescriptorCountLayoutSupportEXT; @@ -31264,6 +34440,11 @@ impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupport &self.inner } } +impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { pub fn max_variable_descriptor_count( mut self, @@ -31272,16 +34453,6 @@ impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { self.inner.max_variable_descriptor_count = max_variable_descriptor_count; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> - where - T: ExtendsDescriptorSetVariableDescriptorCountLayoutSupportEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupportEXT { self.inner } @@ -31330,13 +34501,20 @@ pub struct AttachmentDescription2KHRBuilder<'a> { inner: AttachmentDescription2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAttachmentDescription2KHR {} +pub unsafe trait ExtendsAttachmentDescription2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AttachmentDescription2KHRBuilder<'a> { type Target = AttachmentDescription2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AttachmentDescription2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AttachmentDescription2KHRBuilder<'a> { pub fn flags( mut self, @@ -31389,11 +34567,20 @@ impl<'a> AttachmentDescription2KHRBuilder<'a> { self.inner.final_layout = final_layout; self } - pub fn next(mut self, next: &'a T) -> AttachmentDescription2KHRBuilder<'a> - where - T: ExtendsAttachmentDescription2KHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> AttachmentDescription2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AttachmentDescription2KHR { @@ -31432,13 +34619,20 @@ pub struct AttachmentReference2KHRBuilder<'a> { inner: AttachmentReference2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAttachmentReference2KHR {} +pub unsafe trait ExtendsAttachmentReference2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AttachmentReference2KHRBuilder<'a> { type Target = AttachmentReference2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AttachmentReference2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AttachmentReference2KHRBuilder<'a> { pub fn attachment(mut self, attachment: u32) -> AttachmentReference2KHRBuilder<'a> { self.inner.attachment = attachment; @@ -31455,11 +34649,20 @@ impl<'a> AttachmentReference2KHRBuilder<'a> { self.inner.aspect_mask = aspect_mask; self } - pub fn next(mut self, next: &'a T) -> AttachmentReference2KHRBuilder<'a> - where - T: ExtendsAttachmentReference2KHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> AttachmentReference2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AttachmentReference2KHR { @@ -31514,13 +34717,20 @@ pub struct SubpassDescription2KHRBuilder<'a> { inner: SubpassDescription2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassDescription2KHR {} +pub unsafe trait ExtendsSubpassDescription2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SubpassDescription2KHRBuilder<'a> { type Target = SubpassDescription2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassDescription2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassDescription2KHRBuilder<'a> { pub fn flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescription2KHRBuilder<'a> { self.inner.flags = flags; @@ -31576,11 +34786,20 @@ impl<'a> SubpassDescription2KHRBuilder<'a> { self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> SubpassDescription2KHRBuilder<'a> - where - T: ExtendsSubpassDescription2KHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SubpassDescription2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SubpassDescription2KHR { @@ -31629,13 +34848,20 @@ pub struct SubpassDependency2KHRBuilder<'a> { inner: SubpassDependency2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassDependency2KHR {} +pub unsafe trait ExtendsSubpassDependency2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SubpassDependency2KHRBuilder<'a> { type Target = SubpassDependency2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassDependency2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassDependency2KHRBuilder<'a> { pub fn src_subpass(mut self, src_subpass: u32) -> SubpassDependency2KHRBuilder<'a> { self.inner.src_subpass = src_subpass; @@ -31684,11 +34910,20 @@ impl<'a> SubpassDependency2KHRBuilder<'a> { self.inner.view_offset = view_offset; self } - pub fn next(mut self, next: &'a T) -> SubpassDependency2KHRBuilder<'a> - where - T: ExtendsSubpassDependency2KHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SubpassDependency2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SubpassDependency2KHR { @@ -31739,13 +34974,20 @@ pub struct RenderPassCreateInfo2KHRBuilder<'a> { inner: RenderPassCreateInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassCreateInfo2KHR {} +pub unsafe trait ExtendsRenderPassCreateInfo2KHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for RenderPassCreateInfo2KHRBuilder<'a> { type Target = RenderPassCreateInfo2KHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RenderPassCreateInfo2KHRBuilder<'a> { pub fn flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfo2KHRBuilder<'a> { self.inner.flags = flags; @@ -31783,11 +35025,20 @@ impl<'a> RenderPassCreateInfo2KHRBuilder<'a> { self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> RenderPassCreateInfo2KHRBuilder<'a> - where - T: ExtendsRenderPassCreateInfo2KHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> RenderPassCreateInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> RenderPassCreateInfo2KHR { @@ -31822,23 +35073,39 @@ pub struct SubpassBeginInfoKHRBuilder<'a> { inner: SubpassBeginInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassBeginInfoKHR {} +pub unsafe trait ExtendsSubpassBeginInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SubpassBeginInfoKHRBuilder<'a> { type Target = SubpassBeginInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassBeginInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassBeginInfoKHRBuilder<'a> { pub fn contents(mut self, contents: SubpassContents) -> SubpassBeginInfoKHRBuilder<'a> { self.inner.contents = contents; self } - pub fn next(mut self, next: &'a T) -> SubpassBeginInfoKHRBuilder<'a> - where - T: ExtendsSubpassBeginInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SubpassBeginInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SubpassBeginInfoKHR { @@ -31871,19 +35138,35 @@ pub struct SubpassEndInfoKHRBuilder<'a> { inner: SubpassEndInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassEndInfoKHR {} +pub unsafe trait ExtendsSubpassEndInfoKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for SubpassEndInfoKHRBuilder<'a> { type Target = SubpassEndInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassEndInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassEndInfoKHRBuilder<'a> { - pub fn next(mut self, next: &'a T) -> SubpassEndInfoKHRBuilder<'a> - where - T: ExtendsSubpassEndInfoKHR, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> SubpassEndInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> SubpassEndInfoKHR { @@ -31914,6 +35197,11 @@ impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a &self.inner } } +impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { pub fn binding(mut self, binding: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { self.inner.binding = binding; @@ -31957,10 +35245,19 @@ pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { inner: PipelineVertexInputDivisorStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineVertexInputDivisorStateCreateInfoEXT {} +unsafe impl ExtendsPipelineVertexInputStateCreateInfo + for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineVertexInputStateCreateInfo for PipelineVertexInputDivisorStateCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { type Target = PipelineVertexInputDivisorStateCreateInfoEXT; @@ -31968,6 +35265,11 @@ impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuild &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { pub fn vertex_binding_divisors( mut self, @@ -31977,13 +35279,6 @@ impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> - where - T: ExtendsPipelineVertexInputDivisorStateCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT { self.inner } @@ -32016,14 +35311,29 @@ pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceVertexAttributeDivisorPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { pub fn max_vertex_attrib_divisor( mut self, @@ -32032,16 +35342,6 @@ impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceVertexAttributeDivisorPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { self.inner } @@ -32080,14 +35380,27 @@ pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { inner: PhysicalDevicePCIBusInfoPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDevicePCIBusInfoPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { type Target = PhysicalDevicePCIBusInfoPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { pub fn pci_domain( mut self, @@ -32114,13 +35427,6 @@ impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { self.inner.pci_function = pci_function; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDevicePCIBusInfoPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT { self.inner } @@ -32153,14 +35459,27 @@ pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { inner: ImportAndroidHardwareBufferInfoANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportAndroidHardwareBufferInfoANDROID {} -unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { type Target = ImportAndroidHardwareBufferInfoANDROID; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { pub fn buffer( mut self, @@ -32169,13 +35488,6 @@ impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { self.inner.buffer = buffer; self } - pub fn next(mut self, next: &'a T) -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> - where - T: ExtendsImportAndroidHardwareBufferInfoANDROID, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID { self.inner } @@ -32208,14 +35520,27 @@ pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> { inner: AndroidHardwareBufferUsageANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAndroidHardwareBufferUsageANDROID {} -unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> { type Target = AndroidHardwareBufferUsageANDROID; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> { pub fn android_hardware_buffer_usage( mut self, @@ -32224,13 +35549,6 @@ impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> { self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage; self } - pub fn next(mut self, next: &'a mut T) -> AndroidHardwareBufferUsageANDROIDBuilder<'a> - where - T: ExtendsAndroidHardwareBufferUsageANDROID, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> AndroidHardwareBufferUsageANDROID { self.inner } @@ -32265,13 +35583,20 @@ pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { inner: AndroidHardwareBufferPropertiesANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {} +pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { type Target = AndroidHardwareBufferPropertiesANDROID; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { pub fn allocation_size( mut self, @@ -32287,11 +35612,20 @@ impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - pub fn next(mut self, next: &'a mut T) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> - where - T: ExtendsAndroidHardwareBufferPropertiesANDROID, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID { @@ -32326,13 +35660,20 @@ pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { inner: MemoryGetAndroidHardwareBufferInfoANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetAndroidHardwareBufferInfoANDROID {} +pub unsafe trait ExtendsMemoryGetAndroidHardwareBufferInfoANDROID { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { type Target = MemoryGetAndroidHardwareBufferInfoANDROID; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { pub fn memory( mut self, @@ -32341,11 +35682,20 @@ impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { self.inner.memory = memory; self } - pub fn next(mut self, next: &'a T) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> - where - T: ExtendsMemoryGetAndroidHardwareBufferInfoANDROID, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID { @@ -32394,10 +35744,19 @@ pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { inner: AndroidHardwareBufferFormatPropertiesANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAndroidHardwareBufferFormatPropertiesANDROID {} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID for AndroidHardwareBufferFormatPropertiesANDROID { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { type Target = AndroidHardwareBufferFormatPropertiesANDROID; @@ -32405,6 +35764,11 @@ impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuild &self.inner } } +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { pub fn format( mut self, @@ -32462,16 +35826,6 @@ impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> - where - T: ExtendsAndroidHardwareBufferFormatPropertiesANDROID, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID { self.inner } @@ -32504,10 +35858,19 @@ pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { inner: CommandBufferInheritanceConditionalRenderingInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferInheritanceConditionalRenderingInfoEXT {} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceConditionalRenderingInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { type Target = CommandBufferInheritanceConditionalRenderingInfoEXT; @@ -32515,6 +35878,11 @@ impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoE &self.inner } } +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { pub fn conditional_rendering_enable( mut self, @@ -32523,16 +35891,6 @@ impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { self.inner.conditional_rendering_enable = conditional_rendering_enable.into(); self } - pub fn next( - mut self, - next: &'a T, - ) -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> - where - T: ExtendsCommandBufferInheritanceConditionalRenderingInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT { self.inner } @@ -32565,27 +35923,32 @@ pub struct ExternalFormatANDROIDBuilder<'a> { inner: ExternalFormatANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalFormatANDROID {} -unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {} -unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> { type Target = ExternalFormatANDROID; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ExternalFormatANDROIDBuilder<'a> { pub fn external_format(mut self, external_format: u64) -> ExternalFormatANDROIDBuilder<'a> { self.inner.external_format = external_format; self } - pub fn next(mut self, next: &'a mut T) -> ExternalFormatANDROIDBuilder<'a> - where - T: ExtendsExternalFormatANDROID, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> ExternalFormatANDROID { self.inner } @@ -32622,15 +35985,27 @@ pub struct PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> { inner: PhysicalDevice8BitStorageFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDevice8BitStorageFeaturesKHR {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> { type Target = PhysicalDevice8BitStorageFeaturesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> { pub fn storage_buffer8_bit_access( mut self, @@ -32654,13 +36029,6 @@ impl<'a> PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> { self.inner.storage_push_constant8 = storage_push_constant8.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> - where - T: ExtendsPhysicalDevice8BitStorageFeaturesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDevice8BitStorageFeaturesKHR { self.inner } @@ -32695,15 +36063,27 @@ pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { inner: PhysicalDeviceConditionalRenderingFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceConditionalRenderingFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceConditionalRenderingFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { pub fn conditional_rendering( mut self, @@ -32719,16 +36099,6 @@ impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceConditionalRenderingFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT { self.inner } @@ -32763,15 +36133,27 @@ pub struct PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> { inner: PhysicalDeviceVulkanMemoryModelFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceVulkanMemoryModelFeaturesKHR {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> { type Target = PhysicalDeviceVulkanMemoryModelFeaturesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> { pub fn vulkan_memory_model( mut self, @@ -32787,16 +36169,6 @@ impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> { self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> - where - T: ExtendsPhysicalDeviceVulkanMemoryModelFeaturesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeaturesKHR { self.inner } @@ -32831,15 +36203,27 @@ pub struct PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> { inner: PhysicalDeviceShaderAtomicInt64FeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceShaderAtomicInt64FeaturesKHR {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> { type Target = PhysicalDeviceShaderAtomicInt64FeaturesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> { pub fn shader_buffer_int64_atomics( mut self, @@ -32855,16 +36239,6 @@ impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> { self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> - where - T: ExtendsPhysicalDeviceShaderAtomicInt64FeaturesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceShaderAtomicInt64FeaturesKHR { self.inner } @@ -32899,15 +36273,27 @@ pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceVertexAttributeDivisorFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { pub fn vertex_attribute_instance_rate_divisor( mut self, @@ -32925,16 +36311,6 @@ impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { vertex_attribute_instance_rate_zero_divisor.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceVertexAttributeDivisorFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT { self.inner } @@ -32967,14 +36343,27 @@ pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> { inner: QueueFamilyCheckpointPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsQueueFamilyCheckpointPropertiesNV {} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> { type Target = QueueFamilyCheckpointPropertiesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> { pub fn checkpoint_execution_stage_mask( mut self, @@ -32983,13 +36372,6 @@ impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> { self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; self } - pub fn next(mut self, next: &'a mut T) -> QueueFamilyCheckpointPropertiesNVBuilder<'a> - where - T: ExtendsQueueFamilyCheckpointPropertiesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> QueueFamilyCheckpointPropertiesNV { self.inner } @@ -33024,13 +36406,20 @@ pub struct CheckpointDataNVBuilder<'a> { inner: CheckpointDataNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCheckpointDataNV {} +pub unsafe trait ExtendsCheckpointDataNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> { type Target = CheckpointDataNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CheckpointDataNVBuilder<'a> { pub fn stage(mut self, stage: PipelineStageFlags) -> CheckpointDataNVBuilder<'a> { self.inner.stage = stage; @@ -33043,11 +36432,20 @@ impl<'a> CheckpointDataNVBuilder<'a> { self.inner.p_checkpoint_marker = checkpoint_marker; self } - pub fn next(mut self, next: &'a mut T) -> CheckpointDataNVBuilder<'a> - where - T: ExtendsCheckpointDataNV, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> CheckpointDataNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> CheckpointDataNV { @@ -33088,14 +36486,29 @@ pub struct PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { inner: PhysicalDeviceDepthStencilResolvePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHR {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { type Target = PhysicalDeviceDepthStencilResolvePropertiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { pub fn supported_depth_resolve_modes( mut self, @@ -33125,16 +36538,6 @@ impl<'a> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { self.inner.independent_resolve = independent_resolve.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> - where - T: ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceDepthStencilResolvePropertiesKHR { self.inner } @@ -33171,14 +36574,27 @@ pub struct SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { inner: SubpassDescriptionDepthStencilResolveKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassDescriptionDepthStencilResolveKHR {} -unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHR {} +unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHRBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHR { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { type Target = SubpassDescriptionDepthStencilResolveKHR; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { pub fn depth_resolve_mode( mut self, @@ -33201,171 +36617,6 @@ impl<'a> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; self } - pub fn next(mut self, next: &'a T) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> - where - T: ExtendsSubpassDescriptionDepthStencilResolveKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } - pub fn build(self) -> SubpassDescriptionDepthStencilResolveKHR { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct PhysicalDeviceDepthStencilResolvePropertiesKHR { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub supported_depth_resolve_modes: ResolveModeFlagsKHR, - pub supported_stencil_resolve_modes: ResolveModeFlagsKHR, - pub independent_resolve_none: Bool32, - pub independent_resolve: Bool32, -} -impl ::std::default::Default for PhysicalDeviceDepthStencilResolvePropertiesKHR { - fn default() -> PhysicalDeviceDepthStencilResolvePropertiesKHR { - PhysicalDeviceDepthStencilResolvePropertiesKHR { - s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, - p_next: ::std::ptr::null_mut(), - supported_depth_resolve_modes: ResolveModeFlagsKHR::default(), - supported_stencil_resolve_modes: ResolveModeFlagsKHR::default(), - independent_resolve_none: Bool32::default(), - independent_resolve: Bool32::default(), - } - } -} -impl PhysicalDeviceDepthStencilResolvePropertiesKHR { - pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder { - inner: PhysicalDeviceDepthStencilResolvePropertiesKHR::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - inner: PhysicalDeviceDepthStencilResolvePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - type Target = PhysicalDeviceDepthStencilResolvePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - pub fn supported_depth_resolve_modes( - mut self, - supported_depth_resolve_modes: ResolveModeFlagsKHR, - ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; - self - } - pub fn supported_stencil_resolve_modes( - mut self, - supported_stencil_resolve_modes: ResolveModeFlagsKHR, - ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; - self - } - pub fn independent_resolve_none( - mut self, - independent_resolve_none: bool, - ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - self.inner.independent_resolve_none = independent_resolve_none.into(); - self - } - pub fn independent_resolve( - mut self, - independent_resolve: bool, - ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { - self.inner.independent_resolve = independent_resolve.into(); - self - } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> - where - T: ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } - pub fn build(self) -> PhysicalDeviceDepthStencilResolvePropertiesKHR { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct SubpassDescriptionDepthStencilResolveKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub depth_resolve_mode: ResolveModeFlagsKHR, - pub stencil_resolve_mode: ResolveModeFlagsKHR, - pub p_depth_stencil_resolve_attachment: *const AttachmentReference2KHR, -} -impl ::std::default::Default for SubpassDescriptionDepthStencilResolveKHR { - fn default() -> SubpassDescriptionDepthStencilResolveKHR { - SubpassDescriptionDepthStencilResolveKHR { - s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR, - p_next: ::std::ptr::null(), - depth_resolve_mode: ResolveModeFlagsKHR::default(), - stencil_resolve_mode: ResolveModeFlagsKHR::default(), - p_depth_stencil_resolve_attachment: ::std::ptr::null(), - } - } -} -impl SubpassDescriptionDepthStencilResolveKHR { - pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { - SubpassDescriptionDepthStencilResolveKHRBuilder { - inner: SubpassDescriptionDepthStencilResolveKHR::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { - inner: SubpassDescriptionDepthStencilResolveKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsSubpassDescriptionDepthStencilResolveKHR {} -unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHR {} -impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { - type Target = SubpassDescriptionDepthStencilResolveKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { - pub fn depth_resolve_mode( - mut self, - depth_resolve_mode: ResolveModeFlagsKHR, - ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { - self.inner.depth_resolve_mode = depth_resolve_mode; - self - } - pub fn stencil_resolve_mode( - mut self, - stencil_resolve_mode: ResolveModeFlagsKHR, - ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { - self.inner.stencil_resolve_mode = stencil_resolve_mode; - self - } - pub fn depth_stencil_resolve_attachment( - mut self, - depth_stencil_resolve_attachment: &'a AttachmentReference2KHR, - ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { - self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; - self - } - pub fn next(mut self, next: &'a T) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> - where - T: ExtendsSubpassDescriptionDepthStencilResolveKHR, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> SubpassDescriptionDepthStencilResolveKHR { self.inner } @@ -33398,26 +36649,32 @@ pub struct ImageViewASTCDecodeModeEXTBuilder<'a> { inner: ImageViewASTCDecodeModeEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageViewASTCDecodeModeEXT {} -unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> { type Target = ImageViewASTCDecodeModeEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> { pub fn decode_mode(mut self, decode_mode: Format) -> ImageViewASTCDecodeModeEXTBuilder<'a> { self.inner.decode_mode = decode_mode; self } - pub fn next(mut self, next: &'a T) -> ImageViewASTCDecodeModeEXTBuilder<'a> - where - T: ExtendsImageViewASTCDecodeModeEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImageViewASTCDecodeModeEXT { self.inner } @@ -33450,15 +36707,27 @@ pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { inner: PhysicalDeviceASTCDecodeFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceASTCDecodeFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceASTCDecodeFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { pub fn decode_mode_shared_exponent( mut self, @@ -33467,13 +36736,6 @@ impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceASTCDecodeFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT { self.inner } @@ -33508,15 +36770,27 @@ pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { inner: PhysicalDeviceTransformFeedbackFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceTransformFeedbackFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceTransformFeedbackFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { pub fn transform_feedback( mut self, @@ -33532,16 +36806,6 @@ impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { self.inner.geometry_streams = geometry_streams.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceTransformFeedbackFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT { self.inner } @@ -33592,14 +36856,29 @@ pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { inner: PhysicalDeviceTransformFeedbackPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceTransformFeedbackPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceTransformFeedbackPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { pub fn max_transform_feedback_streams( mut self, @@ -33676,16 +36955,6 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { self.inner.transform_feedback_draw = transform_feedback_draw.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceTransformFeedbackPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT { self.inner } @@ -33720,10 +36989,19 @@ pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { inner: PipelineRasterizationStateStreamCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineRasterizationStateStreamCreateInfoEXT {} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationStateStreamCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { type Target = PipelineRasterizationStateStreamCreateInfoEXT; @@ -33731,6 +37009,11 @@ impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuil &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { pub fn flags( mut self, @@ -33746,16 +37029,6 @@ impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { self.inner.rasterization_stream = rasterization_stream; self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> - where - T: ExtendsPipelineRasterizationStateStreamCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT { self.inner } @@ -33788,15 +37061,29 @@ pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceRepresentativeFragmentTestFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { pub fn representative_fragment_test( mut self, @@ -33805,16 +37092,6 @@ impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { self.inner.representative_fragment_test = representative_fragment_test.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceRepresentativeFragmentTestFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV { self.inner } @@ -33847,10 +37124,19 @@ pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { inner: PipelineRepresentativeFragmentTestStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineRepresentativeFragmentTestStateCreateInfoNV {} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRepresentativeFragmentTestStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV; @@ -33858,6 +37144,11 @@ impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfo &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { pub fn representative_fragment_test_enable( mut self, @@ -33866,16 +37157,6 @@ impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into(); self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineRepresentativeFragmentTestStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV { self.inner } @@ -33908,15 +37189,27 @@ pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { inner: PhysicalDeviceExclusiveScissorFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExclusiveScissorFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { type Target = PhysicalDeviceExclusiveScissorFeaturesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { pub fn exclusive_scissor( mut self, @@ -33925,13 +37218,6 @@ impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { self.inner.exclusive_scissor = exclusive_scissor.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceExclusiveScissorFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV { self.inner } @@ -33966,10 +37252,19 @@ pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { inner: PipelineViewportExclusiveScissorStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineViewportExclusiveScissorStateCreateInfoNV {} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportExclusiveScissorStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportExclusiveScissorStateCreateInfoNV; @@ -33977,6 +37272,11 @@ impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNV &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { pub fn exclusive_scissors( mut self, @@ -33986,16 +37286,6 @@ impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr(); self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineViewportExclusiveScissorStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV { self.inner } @@ -34028,15 +37318,27 @@ pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { inner: PhysicalDeviceCornerSampledImageFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceCornerSampledImageFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { type Target = PhysicalDeviceCornerSampledImageFeaturesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { pub fn corner_sampled_image( mut self, @@ -34045,16 +37347,6 @@ impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { self.inner.corner_sampled_image = corner_sampled_image.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceCornerSampledImageFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV { self.inner } @@ -34089,15 +37381,29 @@ pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceComputeShaderDerivativesFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { pub fn compute_derivative_group_quads( mut self, @@ -34113,16 +37419,6 @@ impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceComputeShaderDerivativesFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV { self.inner } @@ -34155,15 +37451,29 @@ pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceFragmentShaderBarycentricFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} 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> { pub fn fragment_shader_barycentric( mut self, @@ -34172,16 +37482,6 @@ impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceFragmentShaderBarycentricFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV { self.inner } @@ -34214,15 +37514,27 @@ pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { inner: PhysicalDeviceShaderImageFootprintFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceShaderImageFootprintFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { type Target = PhysicalDeviceShaderImageFootprintFeaturesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { pub fn image_footprint( mut self, @@ -34231,16 +37543,6 @@ impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { self.inner.image_footprint = image_footprint.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceShaderImageFootprintFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV { self.inner } @@ -34277,6 +37579,11 @@ impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ShadingRatePaletteNVBuilder<'a> { pub fn shading_rate_palette_entries( mut self, @@ -34322,10 +37629,19 @@ pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { inner: PipelineViewportShadingRateImageStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineViewportShadingRateImageStateCreateInfoNV {} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportShadingRateImageStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportShadingRateImageStateCreateInfoNV; @@ -34333,6 +37649,11 @@ impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNV &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { pub fn shading_rate_image_enable( mut self, @@ -34349,16 +37670,6 @@ impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr(); self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineViewportShadingRateImageStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV { self.inner } @@ -34393,15 +37704,27 @@ pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { inner: PhysicalDeviceShadingRateImageFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceShadingRateImageFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { type Target = PhysicalDeviceShadingRateImageFeaturesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { pub fn shading_rate_image( mut self, @@ -34417,13 +37740,6 @@ impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceShadingRateImageFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV { self.inner } @@ -34460,14 +37776,29 @@ pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { inner: PhysicalDeviceShadingRateImagePropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceShadingRateImagePropertiesNV {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { type Target = PhysicalDeviceShadingRateImagePropertiesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { pub fn shading_rate_texel_size( mut self, @@ -34490,16 +37821,6 @@ impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples; self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceShadingRateImagePropertiesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV { self.inner } @@ -34529,6 +37850,11 @@ impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CoarseSampleLocationNVBuilder<'a> { pub fn pixel_x(mut self, pixel_x: u32) -> CoarseSampleLocationNVBuilder<'a> { self.inner.pixel_x = pixel_x; @@ -34582,6 +37908,11 @@ impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> CoarseSampleOrderCustomNVBuilder<'a> { pub fn shading_rate( mut self, @@ -34638,10 +37969,19 @@ pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineViewportCoarseSampleOrderStateCreateInfoNV {} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportCoarseSampleOrderStateCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } } impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV; @@ -34649,6 +37989,11 @@ impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoN &self.inner } } +impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { pub fn sample_order_type( mut self, @@ -34665,16 +38010,6 @@ impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr(); self } - pub fn next( - mut self, - next: &'a T, - ) -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> - where - T: ExtendsPipelineViewportCoarseSampleOrderStateCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV { self.inner } @@ -34709,15 +38044,27 @@ pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { inner: PhysicalDeviceMeshShaderFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMeshShaderFeaturesNV {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { type Target = PhysicalDeviceMeshShaderFeaturesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { pub fn task_shader( mut self, @@ -34733,13 +38080,6 @@ impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { self.inner.mesh_shader = mesh_shader.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceMeshShaderFeaturesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV { self.inner } @@ -34796,14 +38136,27 @@ pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { inner: PhysicalDeviceMeshShaderPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMeshShaderPropertiesNV {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { type Target = PhysicalDeviceMeshShaderPropertiesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { pub fn max_draw_mesh_tasks_count( mut self, @@ -34896,13 +38249,6 @@ impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceMeshShaderPropertiesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV { self.inner } @@ -34931,6 +38277,11 @@ impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> { pub fn task_count(mut self, task_count: u32) -> DrawMeshTasksIndirectCommandNVBuilder<'a> { self.inner.task_count = task_count; @@ -34980,13 +38331,20 @@ pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> { inner: RayTracingShaderGroupCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoNV {} +pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> { type Target = RayTracingShaderGroupCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { pub fn ty( mut self, @@ -35023,11 +38381,20 @@ impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { self.inner.intersection_shader = intersection_shader; self } - pub fn next(mut self, next: &'a T) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> - where - T: ExtendsRayTracingShaderGroupCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> RayTracingShaderGroupCreateInfoNV { @@ -35078,13 +38445,20 @@ pub struct RayTracingPipelineCreateInfoNVBuilder<'a> { inner: RayTracingPipelineCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {} +pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> { type Target = RayTracingPipelineCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { pub fn flags( mut self, @@ -35134,11 +38508,20 @@ impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { self.inner.base_pipeline_index = base_pipeline_index; self } - pub fn next(mut self, next: &'a T) -> RayTracingPipelineCreateInfoNVBuilder<'a> - where - T: ExtendsRayTracingPipelineCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> RayTracingPipelineCreateInfoNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> RayTracingPipelineCreateInfoNV { @@ -35193,13 +38576,20 @@ pub struct GeometryTrianglesNVBuilder<'a> { inner: GeometryTrianglesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryTrianglesNV {} +pub unsafe trait ExtendsGeometryTrianglesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> { type Target = GeometryTrianglesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> GeometryTrianglesNVBuilder<'a> { pub fn vertex_data(mut self, vertex_data: Buffer) -> GeometryTrianglesNVBuilder<'a> { self.inner.vertex_data = vertex_data; @@ -35248,11 +38638,20 @@ impl<'a> GeometryTrianglesNVBuilder<'a> { self.inner.transform_offset = transform_offset; self } - pub fn next(mut self, next: &'a T) -> GeometryTrianglesNVBuilder<'a> - where - T: ExtendsGeometryTrianglesNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> GeometryTrianglesNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> GeometryTrianglesNV { @@ -35293,13 +38692,20 @@ pub struct GeometryAABBNVBuilder<'a> { inner: GeometryAABBNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryAABBNV {} +pub unsafe trait ExtendsGeometryAABBNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> { type Target = GeometryAABBNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> GeometryAABBNVBuilder<'a> { pub fn aabb_data(mut self, aabb_data: Buffer) -> GeometryAABBNVBuilder<'a> { self.inner.aabb_data = aabb_data; @@ -35317,11 +38723,20 @@ impl<'a> GeometryAABBNVBuilder<'a> { self.inner.offset = offset; self } - pub fn next(mut self, next: &'a T) -> GeometryAABBNVBuilder<'a> - where - T: ExtendsGeometryAABBNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> GeometryAABBNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> GeometryAABBNV { @@ -35352,6 +38767,11 @@ impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> GeometryDataNVBuilder<'a> { pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> GeometryDataNVBuilder<'a> { self.inner.triangles = triangles; @@ -35397,13 +38817,20 @@ pub struct GeometryNVBuilder<'a> { inner: GeometryNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryNV {} +pub unsafe trait ExtendsGeometryNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> { type Target = GeometryNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> GeometryNVBuilder<'a> { pub fn geometry_type(mut self, geometry_type: GeometryTypeNV) -> GeometryNVBuilder<'a> { self.inner.geometry_type = geometry_type; @@ -35417,11 +38844,17 @@ impl<'a> GeometryNVBuilder<'a> { self.inner.flags = flags; self } - pub fn next(mut self, next: &'a T) -> GeometryNVBuilder<'a> - where - T: ExtendsGeometryNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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) -> GeometryNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> GeometryNV { @@ -35464,13 +38897,20 @@ pub struct AccelerationStructureInfoNVBuilder<'a> { inner: AccelerationStructureInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureInfoNV {} +pub unsafe trait ExtendsAccelerationStructureInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> { type Target = AccelerationStructureInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AccelerationStructureInfoNVBuilder<'a> { pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> AccelerationStructureInfoNVBuilder<'a> { self.inner.ty = ty; @@ -35495,11 +38935,20 @@ impl<'a> AccelerationStructureInfoNVBuilder<'a> { self.inner.p_geometries = geometries.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> AccelerationStructureInfoNVBuilder<'a> - where - T: ExtendsAccelerationStructureInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> AccelerationStructureInfoNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AccelerationStructureInfoNV { @@ -35536,13 +38985,20 @@ pub struct AccelerationStructureCreateInfoNVBuilder<'a> { inner: AccelerationStructureCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {} +pub unsafe trait ExtendsAccelerationStructureCreateInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> { type Target = AccelerationStructureCreateInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { pub fn compacted_size( mut self, @@ -35558,11 +39014,20 @@ impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { self.inner.info = info; self } - pub fn next(mut self, next: &'a T) -> AccelerationStructureCreateInfoNVBuilder<'a> - where - T: ExtendsAccelerationStructureCreateInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> AccelerationStructureCreateInfoNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AccelerationStructureCreateInfoNV { @@ -35605,13 +39070,20 @@ pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> { inner: BindAccelerationStructureMemoryInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoNV {} +pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> { type Target = BindAccelerationStructureMemoryInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { pub fn acceleration_structure( mut self, @@ -35642,11 +39114,20 @@ impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { self.inner.p_device_indices = device_indices.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> - where - T: ExtendsBindAccelerationStructureMemoryInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BindAccelerationStructureMemoryInfoNV { @@ -35683,14 +39164,27 @@ pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> { inner: WriteDescriptorSetAccelerationStructureNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWriteDescriptorSetAccelerationStructureNV {} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { type Target = WriteDescriptorSetAccelerationStructureNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { pub fn acceleration_structures( mut self, @@ -35700,13 +39194,6 @@ impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> - where - T: ExtendsWriteDescriptorSetAccelerationStructureNV, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV { self.inner } @@ -35741,13 +39228,20 @@ pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { inner: AccelerationStructureMemoryRequirementsInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoNV {} +pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { type Target = AccelerationStructureMemoryRequirementsInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { pub fn ty( mut self, @@ -35763,14 +39257,20 @@ impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { self.inner.acceleration_structure = acceleration_structure; self } - pub fn next( + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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 T, - ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> - where - T: ExtendsAccelerationStructureMemoryRequirementsInfoNV, - { - self.inner.p_next = next as *const T as *const c_void; + next: &'a mut T, + ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV { @@ -35819,14 +39319,27 @@ pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { inner: PhysicalDeviceRayTracingPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceRayTracingPropertiesNV {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { type Target = PhysicalDeviceRayTracingPropertiesNV; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { pub fn shader_group_handle_size( mut self, @@ -35885,13 +39398,6 @@ impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { max_descriptor_set_acceleration_structures; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> - where - T: ExtendsPhysicalDeviceRayTracingPropertiesNV, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV { self.inner } @@ -35926,14 +39432,27 @@ pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> { inner: DrmFormatModifierPropertiesListEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDrmFormatModifierPropertiesListEXT {} -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> { type Target = DrmFormatModifierPropertiesListEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> { pub fn drm_format_modifier_properties( mut self, @@ -35943,13 +39462,6 @@ impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> { self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); self } - pub fn next(mut self, next: &'a mut T) -> DrmFormatModifierPropertiesListEXTBuilder<'a> - where - T: ExtendsDrmFormatModifierPropertiesListEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> DrmFormatModifierPropertiesListEXT { self.inner } @@ -35979,6 +39491,11 @@ impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> { &self.inner } } +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> { pub fn drm_format_modifier( mut self, @@ -36039,14 +39556,29 @@ pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { inner: PhysicalDeviceImageDrmFormatModifierInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceImageDrmFormatModifierInfoEXT {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { pub fn drm_format_modifier( mut self, @@ -36070,13 +39602,6 @@ impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceImageDrmFormatModifierInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT { self.inner } @@ -36111,14 +39636,27 @@ pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { inner: ImageDrmFormatModifierListCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageDrmFormatModifierListCreateInfoEXT {} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { type Target = ImageDrmFormatModifierListCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { pub fn drm_format_modifiers( mut self, @@ -36128,13 +39666,6 @@ impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> - where - T: ExtendsImageDrmFormatModifierListCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT { self.inner } @@ -36171,14 +39702,27 @@ pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { inner: ImageDrmFormatModifierExplicitCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageDrmFormatModifierExplicitCreateInfoEXT {} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { type Target = ImageDrmFormatModifierExplicitCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { pub fn drm_format_modifier( mut self, @@ -36195,13 +39739,6 @@ impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { self.inner.p_plane_layouts = plane_layouts.as_ptr(); self } - pub fn next(mut self, next: &'a T) -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> - where - T: ExtendsImageDrmFormatModifierExplicitCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT { self.inner } @@ -36234,13 +39771,20 @@ pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> { inner: ImageDrmFormatModifierPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageDrmFormatModifierPropertiesEXT {} +pub unsafe trait ExtendsImageDrmFormatModifierPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { type Target = ImageDrmFormatModifierPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { pub fn drm_format_modifier( mut self, @@ -36249,11 +39793,20 @@ impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { self.inner.drm_format_modifier = drm_format_modifier; self } - pub fn next(mut self, next: &'a mut T) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> - where - T: ExtendsImageDrmFormatModifierPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT { @@ -36288,15 +39841,27 @@ pub struct ImageStencilUsageCreateInfoEXTBuilder<'a> { inner: ImageStencilUsageCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageStencilUsageCreateInfoEXT {} -unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXT {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoEXTBuilder<'a> { type Target = ImageStencilUsageCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> ImageStencilUsageCreateInfoEXTBuilder<'a> { pub fn stencil_usage( mut self, @@ -36305,13 +39870,6 @@ impl<'a> ImageStencilUsageCreateInfoEXTBuilder<'a> { self.inner.stencil_usage = stencil_usage; self } - pub fn next(mut self, next: &'a T) -> ImageStencilUsageCreateInfoEXTBuilder<'a> - where - T: ExtendsImageStencilUsageCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> ImageStencilUsageCreateInfoEXT { self.inner } @@ -36344,14 +39902,27 @@ pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { inner: DeviceMemoryOverallocationCreateInfoAMD, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceMemoryOverallocationCreateInfoAMD {} -unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { type Target = DeviceMemoryOverallocationCreateInfoAMD; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { pub fn overallocation_behavior( mut self, @@ -36360,13 +39931,6 @@ impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { self.inner.overallocation_behavior = overallocation_behavior; self } - pub fn next(mut self, next: &'a T) -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> - where - T: ExtendsDeviceMemoryOverallocationCreateInfoAMD, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD { self.inner } @@ -36403,15 +39967,27 @@ pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { pub fn fragment_density_map( mut self, @@ -36435,16 +40011,6 @@ impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { fragment_density_map_non_subsampled_images.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT { self.inner } @@ -36481,14 +40047,29 @@ pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { pub fn min_fragment_density_texel_size( mut self, @@ -36511,16 +40092,6 @@ impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { self.inner.fragment_density_invocations = fragment_density_invocations.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT { self.inner } @@ -36553,14 +40124,27 @@ pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { inner: RenderPassFragmentDensityMapCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassFragmentDensityMapCreateInfoEXT {} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { type Target = RenderPassFragmentDensityMapCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { pub fn fragment_density_map_attachment( mut self, @@ -36569,13 +40153,6 @@ impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { self.inner.fragment_density_map_attachment = fragment_density_map_attachment; self } - pub fn next(mut self, next: &'a T) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> - where - T: ExtendsRenderPassFragmentDensityMapCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT { self.inner } @@ -36608,15 +40185,27 @@ pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceScalarBlockLayoutFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { pub fn scalar_block_layout( mut self, @@ -36625,16 +40214,6 @@ impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { self.inner.scalar_block_layout = scalar_block_layout.into(); self } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeaturesEXT { self.inner } @@ -36669,14 +40248,29 @@ pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { inner: PhysicalDeviceMemoryBudgetPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 + for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_> +{ + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { pub fn heap_budget( mut self, @@ -36692,13 +40286,6 @@ impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { self.inner.heap_usage = heap_usage; self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT { self.inner } @@ -36731,15 +40318,27 @@ pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { inner: PhysicalDeviceMemoryPriorityFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { pub fn memory_priority( mut self, @@ -36748,13 +40347,6 @@ impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { self.inner.memory_priority = memory_priority.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT { self.inner } @@ -36787,26 +40379,32 @@ pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { inner: MemoryPriorityAllocateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryPriorityAllocateInfoEXT {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { type Target = MemoryPriorityAllocateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> { pub fn priority(mut self, priority: f32) -> MemoryPriorityAllocateInfoEXTBuilder<'a> { self.inner.priority = priority; self } - pub fn next(mut self, next: &'a T) -> MemoryPriorityAllocateInfoEXTBuilder<'a> - where - T: ExtendsMemoryPriorityAllocateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> MemoryPriorityAllocateInfoEXT { self.inner } @@ -36843,15 +40441,27 @@ pub struct PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { inner: PhysicalDeviceBufferAddressFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceBufferAddressFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferAddressFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceBufferAddressFeaturesEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { pub fn buffer_device_address( mut self, @@ -36875,13 +40485,6 @@ impl<'a> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); self } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceBufferAddressFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } pub fn build(self) -> PhysicalDeviceBufferAddressFeaturesEXT { self.inner } @@ -36914,23 +40517,39 @@ pub struct BufferDeviceAddressInfoEXTBuilder<'a> { inner: BufferDeviceAddressInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferDeviceAddressInfoEXT {} +pub unsafe trait ExtendsBufferDeviceAddressInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoEXTBuilder<'a> { type Target = BufferDeviceAddressInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferDeviceAddressInfoEXTBuilder<'a> { pub fn buffer(mut self, buffer: Buffer) -> BufferDeviceAddressInfoEXTBuilder<'a> { self.inner.buffer = buffer; self } - pub fn next(mut self, next: &'a T) -> BufferDeviceAddressInfoEXTBuilder<'a> - where - T: ExtendsBufferDeviceAddressInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on create infos 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, + ) -> BufferDeviceAddressInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> BufferDeviceAddressInfoEXT { @@ -36965,14 +40584,27 @@ pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { inner: BufferDeviceAddressCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferDeviceAddressCreateInfoEXT {} -unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(&mut self.inner) + } +} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { type Target = BufferDeviceAddressCreateInfoEXT; fn deref(&self) -> &Self::Target { &self.inner } } +impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { pub fn device_address( mut self, @@ -36981,634 +40613,6 @@ impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { self.inner.device_address = device_address; self } - pub fn next(mut self, next: &'a T) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> - where - T: ExtendsBufferDeviceAddressCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } - pub fn build(self) -> BufferDeviceAddressCreateInfoEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub fragment_density_map: Bool32, - pub fragment_density_map_dynamic: Bool32, - pub fragment_density_map_non_subsampled_images: Bool32, -} -impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT { - fn default() -> PhysicalDeviceFragmentDensityMapFeaturesEXT { - PhysicalDeviceFragmentDensityMapFeaturesEXT { - s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, - p_next: ::std::ptr::null_mut(), - fragment_density_map: Bool32::default(), - fragment_density_map_dynamic: Bool32::default(), - fragment_density_map_non_subsampled_images: Bool32::default(), - } - } -} -impl PhysicalDeviceFragmentDensityMapFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder { - inner: PhysicalDeviceFragmentDensityMapFeaturesEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - pub fn fragment_density_map( - mut self, - fragment_density_map: bool, - ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - self.inner.fragment_density_map = fragment_density_map.into(); - self - } - pub fn fragment_density_map_dynamic( - mut self, - fragment_density_map_dynamic: bool, - ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into(); - self - } - pub fn fragment_density_map_non_subsampled_images( - mut self, - fragment_density_map_non_subsampled_images: bool, - ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - self.inner.fragment_density_map_non_subsampled_images = - fragment_density_map_non_subsampled_images.into(); - self - } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } - pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub min_fragment_density_texel_size: Extent2D, - pub max_fragment_density_texel_size: Extent2D, - pub fragment_density_invocations: Bool32, -} -impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT { - fn default() -> PhysicalDeviceFragmentDensityMapPropertiesEXT { - PhysicalDeviceFragmentDensityMapPropertiesEXT { - s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, - p_next: ::std::ptr::null_mut(), - min_fragment_density_texel_size: Extent2D::default(), - max_fragment_density_texel_size: Extent2D::default(), - fragment_density_invocations: Bool32::default(), - } - } -} -impl PhysicalDeviceFragmentDensityMapPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder { - inner: PhysicalDeviceFragmentDensityMapPropertiesEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - pub fn min_fragment_density_texel_size( - mut self, - min_fragment_density_texel_size: Extent2D, - ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size; - self - } - pub fn max_fragment_density_texel_size( - mut self, - max_fragment_density_texel_size: Extent2D, - ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size; - self - } - pub fn fragment_density_invocations( - mut self, - fragment_density_invocations: bool, - ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - self.inner.fragment_density_invocations = fragment_density_invocations.into(); - self - } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } - pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct RenderPassFragmentDensityMapCreateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub fragment_density_map_attachment: AttachmentReference, -} -impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT { - fn default() -> RenderPassFragmentDensityMapCreateInfoEXT { - RenderPassFragmentDensityMapCreateInfoEXT { - s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, - p_next: ::std::ptr::null(), - fragment_density_map_attachment: AttachmentReference::default(), - } - } -} -impl RenderPassFragmentDensityMapCreateInfoEXT { - pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - RenderPassFragmentDensityMapCreateInfoEXTBuilder { - inner: RenderPassFragmentDensityMapCreateInfoEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - inner: RenderPassFragmentDensityMapCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsRenderPassFragmentDensityMapCreateInfoEXT {} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} -impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - type Target = RenderPassFragmentDensityMapCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - pub fn fragment_density_map_attachment( - mut self, - fragment_density_map_attachment: AttachmentReference, - ) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - self.inner.fragment_density_map_attachment = fragment_density_map_attachment; - self - } - pub fn next(mut self, next: &'a T) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> - where - T: ExtendsRenderPassFragmentDensityMapCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } - pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXT { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub scalar_block_layout: Bool32, -} -impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeaturesEXT { - fn default() -> PhysicalDeviceScalarBlockLayoutFeaturesEXT { - PhysicalDeviceScalarBlockLayoutFeaturesEXT { - s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, - p_next: ::std::ptr::null_mut(), - scalar_block_layout: Bool32::default(), - } - } -} -impl PhysicalDeviceScalarBlockLayoutFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { - PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder { - inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceScalarBlockLayoutFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { - pub fn scalar_block_layout( - mut self, - scalar_block_layout: bool, - ) -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { - self.inner.scalar_block_layout = scalar_block_layout.into(); - self - } - pub fn next( - mut self, - next: &'a mut T, - ) -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } - pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeaturesEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct PhysicalDeviceMemoryBudgetPropertiesEXT { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], - pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], -} -impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT { - fn default() -> PhysicalDeviceMemoryBudgetPropertiesEXT { - PhysicalDeviceMemoryBudgetPropertiesEXT { - s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, - p_next: ::std::ptr::null_mut(), - heap_budget: unsafe { ::std::mem::zeroed() }, - heap_usage: unsafe { ::std::mem::zeroed() }, - } - } -} -impl PhysicalDeviceMemoryBudgetPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - PhysicalDeviceMemoryBudgetPropertiesEXTBuilder { - inner: PhysicalDeviceMemoryBudgetPropertiesEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceMemoryBudgetPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT {} -unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - pub fn heap_budget( - mut self, - heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], - ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - self.inner.heap_budget = heap_budget; - self - } - pub fn heap_usage( - mut self, - heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], - ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - self.inner.heap_usage = heap_usage; - self - } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } - pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct PhysicalDeviceMemoryPriorityFeaturesEXT { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub memory_priority: Bool32, -} -impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT { - fn default() -> PhysicalDeviceMemoryPriorityFeaturesEXT { - PhysicalDeviceMemoryPriorityFeaturesEXT { - s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, - p_next: ::std::ptr::null_mut(), - memory_priority: Bool32::default(), - } - } -} -impl PhysicalDeviceMemoryPriorityFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - PhysicalDeviceMemoryPriorityFeaturesEXTBuilder { - inner: PhysicalDeviceMemoryPriorityFeaturesEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceMemoryPriorityFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - pub fn memory_priority( - mut self, - memory_priority: bool, - ) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - self.inner.memory_priority = memory_priority.into(); - self - } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } - pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct MemoryPriorityAllocateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub priority: f32, -} -impl ::std::default::Default for MemoryPriorityAllocateInfoEXT { - fn default() -> MemoryPriorityAllocateInfoEXT { - MemoryPriorityAllocateInfoEXT { - s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT, - p_next: ::std::ptr::null(), - priority: f32::default(), - } - } -} -impl MemoryPriorityAllocateInfoEXT { - pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> { - MemoryPriorityAllocateInfoEXTBuilder { - inner: MemoryPriorityAllocateInfoEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { - inner: MemoryPriorityAllocateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsMemoryPriorityAllocateInfoEXT {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} -impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { - type Target = MemoryPriorityAllocateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> { - pub fn priority(mut self, priority: f32) -> MemoryPriorityAllocateInfoEXTBuilder<'a> { - self.inner.priority = priority; - self - } - pub fn next(mut self, next: &'a T) -> MemoryPriorityAllocateInfoEXTBuilder<'a> - where - T: ExtendsMemoryPriorityAllocateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } - pub fn build(self) -> MemoryPriorityAllocateInfoEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct PhysicalDeviceBufferAddressFeaturesEXT { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub buffer_device_address: Bool32, - pub buffer_device_address_capture_replay: Bool32, - pub buffer_device_address_multi_device: Bool32, -} -impl ::std::default::Default for PhysicalDeviceBufferAddressFeaturesEXT { - fn default() -> PhysicalDeviceBufferAddressFeaturesEXT { - PhysicalDeviceBufferAddressFeaturesEXT { - s_type: StructureType::PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, - p_next: ::std::ptr::null_mut(), - buffer_device_address: Bool32::default(), - buffer_device_address_capture_replay: Bool32::default(), - buffer_device_address_multi_device: Bool32::default(), - } - } -} -impl PhysicalDeviceBufferAddressFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { - PhysicalDeviceBufferAddressFeaturesEXTBuilder { - inner: PhysicalDeviceBufferAddressFeaturesEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceBufferAddressFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsPhysicalDeviceBufferAddressFeaturesEXT {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferAddressFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceBufferAddressFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { - pub fn buffer_device_address( - mut self, - buffer_device_address: bool, - ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { - self.inner.buffer_device_address = buffer_device_address.into(); - self - } - pub fn buffer_device_address_capture_replay( - mut self, - buffer_device_address_capture_replay: bool, - ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { - self.inner.buffer_device_address_capture_replay = - buffer_device_address_capture_replay.into(); - self - } - pub fn buffer_device_address_multi_device( - mut self, - buffer_device_address_multi_device: bool, - ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { - self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); - self - } - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> - where - T: ExtendsPhysicalDeviceBufferAddressFeaturesEXT, - { - self.inner.p_next = next as *mut T as *mut c_void; - self - } - pub fn build(self) -> PhysicalDeviceBufferAddressFeaturesEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct BufferDeviceAddressInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub buffer: Buffer, -} -impl ::std::default::Default for BufferDeviceAddressInfoEXT { - fn default() -> BufferDeviceAddressInfoEXT { - BufferDeviceAddressInfoEXT { - s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO_EXT, - p_next: ::std::ptr::null(), - buffer: Buffer::default(), - } - } -} -impl BufferDeviceAddressInfoEXT { - pub fn builder<'a>() -> BufferDeviceAddressInfoEXTBuilder<'a> { - BufferDeviceAddressInfoEXTBuilder { - inner: BufferDeviceAddressInfoEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct BufferDeviceAddressInfoEXTBuilder<'a> { - inner: BufferDeviceAddressInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsBufferDeviceAddressInfoEXT {} -impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoEXTBuilder<'a> { - type Target = BufferDeviceAddressInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> BufferDeviceAddressInfoEXTBuilder<'a> { - pub fn buffer(mut self, buffer: Buffer) -> BufferDeviceAddressInfoEXTBuilder<'a> { - self.inner.buffer = buffer; - self - } - pub fn next(mut self, next: &'a T) -> BufferDeviceAddressInfoEXTBuilder<'a> - where - T: ExtendsBufferDeviceAddressInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } - pub fn build(self) -> BufferDeviceAddressInfoEXT { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -pub struct BufferDeviceAddressCreateInfoEXT { - pub s_type: StructureType, - pub p_next: *const c_void, - pub device_address: DeviceSize, -} -impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT { - fn default() -> BufferDeviceAddressCreateInfoEXT { - BufferDeviceAddressCreateInfoEXT { - s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, - p_next: ::std::ptr::null(), - device_address: DeviceSize::default(), - } - } -} -impl BufferDeviceAddressCreateInfoEXT { - pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { - BufferDeviceAddressCreateInfoEXTBuilder { - inner: BufferDeviceAddressCreateInfoEXT::default(), - marker: ::std::marker::PhantomData, - } - } -} -pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { - inner: BufferDeviceAddressCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsBufferDeviceAddressCreateInfoEXT {} -unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} -impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { - type Target = BufferDeviceAddressCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { - pub fn device_address( - mut self, - device_address: DeviceSize, - ) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { - self.inner.device_address = device_address; - self - } - pub fn next(mut self, next: &'a T) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> - where - T: ExtendsBufferDeviceAddressCreateInfoEXT, - { - self.inner.p_next = next as *const T as *const c_void; - self - } pub fn build(self) -> BufferDeviceAddressCreateInfoEXT { self.inner } @@ -55091,23 +58095,49 @@ fn display_flags( } Ok(()) } -<<<<<<< HEAD -impl fmt::Display for CommandBufferLevel { +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), -======= -impl fmt::Display for DescriptorSetLayoutCreateFlags { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", ), ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", ), ]; display_flags(f, KNOWN, self.0) @@ -55119,7 +58149,6 @@ impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { Self::OBJECT => Some("OBJECT"), Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), ->>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -55129,302 +58158,22 @@ impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { } } } -<<<<<<< HEAD -impl fmt::Display for MemoryOverallocationBehaviorAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::ALLOWED => Some("ALLOWED"), - Self::DISALLOWED => Some("DISALLOWED"), -======= -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), -======= -impl fmt::Display for AccelerationStructureTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), - ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), -======= -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_BUFFER_EXT", - ), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", - ), - ( - BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), ->>>>>>> Implement extension chaining - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for GeometryTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TRIANGLES => Some("TRIANGLES"), - Self::AABBS => Some("AABBS"), -======= -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for DebugReportObjectTypeEXT { -======= impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -55444,47 +58193,13 @@ impl fmt::Display for CommandBufferUsageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectType { ->>>>>>> Implement extension chaining +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -55494,402 +58209,38 @@ impl fmt::Display for ObjectType { } } } -<<<<<<< HEAD -impl fmt::Display for SamplerCreateFlags { +impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ShaderStageFlags::VERTEX.0, "VERTEX"), ( - SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, - "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), + (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), + (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), + (ShaderStageFlags::MISS_NV.0, "MISS_NV"), + (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), + (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), + (ShaderStageFlags::TASK_NV.0, "TASK_NV"), + (ShaderStageFlags::MESH_NV.0, "MESH_NV"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ResolveModeFlagsKHR { +impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ResolveModeFlagsKHR::NONE.0, "NONE"), - (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), - (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), - (ResolveModeFlagsKHR::MIN.0, "MIN"), - (ResolveModeFlagsKHR::MAX.0, "MAX"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DriverIdKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), - Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), - Self::MESA_RADV => Some("MESA_RADV"), - Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), - Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), - Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), - Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), - Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), - Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), - Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), -======= -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), - (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), - ( - PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, - "TRANSFORM_FEEDBACK_EXT", - ), - ( - PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ( - PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - PipelineStageFlags::RAY_TRACING_SHADER_NV.0, - "RAY_TRACING_SHADER_NV", - ), - ( - PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, - "ACCELERATION_STRUCTURE_BUILD_NV", - ), - (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), - (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), - ( - PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, - "FRAGMENT_DENSITY_PROCESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), -======= -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), -======= -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RayTracingShaderGroupTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), -======= -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } -<<<<<<< HEAD - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) -======= ->>>>>>> Implement extension chaining - } -} -impl fmt::Display for ValidationFeatureDisableEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - Self::THREAD_SAFETY => Some("THREAD_SAFETY"), - Self::API_PARAMETERS => Some("API_PARAMETERS"), - Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), - Self::CORE_CHECKS => Some("CORE_CHECKS"), - Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShadingRatePaletteEntryNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), - Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), - Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), - Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), - Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), - Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } @@ -55956,17 +58307,366 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for CompareOp { +impl fmt::Display for ValidationFeatureDisableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), + (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ResolveModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ResolveModeFlagsKHR::NONE.0, "NONE"), + (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), + (ResolveModeFlagsKHR::MIN.0, "MIN"), + (ResolveModeFlagsKHR::MAX.0, "MAX"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), _ => None, }; if let Some(x) = name { @@ -55998,176 +58698,11 @@ impl fmt::Display for PipelineCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), - (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_BUFFER_EXT", - ), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", - ), - ( - BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), - ( - BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, - "SHADER_DEVICE_ADDRESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), - (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OBJECT => Some("OBJECT"), - Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), - Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), _ => None, }; if let Some(x) = name { @@ -56192,890 +58727,19 @@ impl fmt::Display for DescriptorPoolCreateFlags { display_flags(f, KNOWN, self.0) } } -======= -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: RESERVED_24_EXT . 0 , "RESERVED_24_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} ->>>>>>> Implement extension chaining -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferUsageFlags { +impl fmt::Display for StencilFaceFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccelerationStructureTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - ( - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, - "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", - ), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoarseSampleOrderTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), - (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), - (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RenderPassCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -======= ->>>>>>> Implement extension chaining -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), - (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), - (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), - (ShaderStageFlags::MISS_NV.0, "MISS_NV"), - (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), - (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), - (ShaderStageFlags::TASK_NV.0, "TASK_NV"), - (ShaderStageFlags::MESH_NV.0, "MESH_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ExternalMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57095,6 +58759,100 @@ impl fmt::Display for ExternalMemoryFeatureFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57188,146 +58946,32 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), - Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), -======= -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), ->>>>>>> Implement extension chaining - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for SampleCountFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for DescriptorType { @@ -57355,24 +58999,11 @@ impl fmt::Display for DescriptorType { } } } -impl fmt::Display for ColorSpaceKHR { +impl fmt::Display for SamplerYcbcrRange { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -57382,28 +59013,99 @@ impl fmt::Display for ColorSpaceKHR { } } } -impl fmt::Display for BlendFactor { +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), + (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), + (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), + ( + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ZERO => Some("ZERO"), Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), _ => None, }; if let Some(x) = name { @@ -57413,8 +59115,160 @@ impl fmt::Display for BlendFactor { } } } -======= ->>>>>>> Implement extension chaining +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, + "LOW_MEMORY", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), + (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, + "SHADER_DEVICE_ADDRESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58049,56 +59903,12 @@ impl fmt::Display for StructureType { } } } -<<<<<<< HEAD -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), - ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", - ), -======= -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShadingRatePaletteEntryNV { +impl fmt::Display for RayTracingShaderGroupTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), - Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), - Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), - Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), - Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), - Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), _ => None, }; if let Some(x) = name { @@ -58108,170 +59918,18 @@ impl fmt::Display for ShadingRatePaletteEntryNV { } } } -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for RenderPassCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - ( - AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_WRITE_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", - ), - ( - AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, - "CONDITIONAL_RENDERING_READ_EXT", - ), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ( - AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, - "SHADING_RATE_IMAGE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, - "ACCELERATION_STRUCTURE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, - "ACCELERATION_STRUCTURE_WRITE_NV", - ), - (AccessFlags::RESERVED_24_EXT.0, "RESERVED_24_EXT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::RESERVED_14_EXT.0, "RESERVED_14_EXT"), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { +impl fmt::Display for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), _ => None, }; if let Some(x) = name { @@ -58281,109 +59939,30 @@ impl fmt::Display for ImageViewType { } } } -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ComponentSwizzle { +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), _ => None, }; if let Some(x) = name { @@ -58393,94 +59972,79 @@ impl fmt::Display for ComponentSwizzle { } } } -impl fmt::Display for IndexType { +impl fmt::Display for SurfaceCounterFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for QueryResultFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58492,13 +60056,13 @@ impl fmt::Display for QueryResultFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CoarseSampleOrderTypeNV { +impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -58508,25 +60072,20 @@ impl fmt::Display for CoarseSampleOrderTypeNV { } } } -impl fmt::Display for LogicOp { +impl fmt::Display for ImageViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationFeatureEnableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), _ => None, }; if let Some(x) = name { @@ -58536,115 +60095,38 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", ), ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ->>>>>>> Implement extension chaining ]; display_flags(f, KNOWN, self.0) } } -<<<<<<< HEAD -impl fmt::Display for FenceCreateFlags { -======= -impl fmt::Display for MemoryOverallocationBehaviorAMD { +impl fmt::Display for BorderColor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::ALLOWED => Some("ALLOWED"), - Self::DISALLOWED => Some("DISALLOWED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), - Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), - Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DriverIdKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), - Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), - Self::MESA_RADV => Some("MESA_RADV"), - Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), - Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), - Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), - Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), - Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), - Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), _ => None, }; if let Some(x) = name { @@ -58667,10 +60149,19 @@ impl fmt::Display for InternalAllocationType { } } } -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for DriverIdKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), _ => None, }; if let Some(x) = name { @@ -58680,56 +60171,35 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for MemoryHeapFlags { +impl fmt::Display for DescriptorBindingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { +impl fmt::Display for SamplerReductionModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), _ => None, }; if let Some(x) = name { @@ -58739,152 +60209,52 @@ impl fmt::Display for CommandBufferLevel { } } } -impl fmt::Display for ConditionalRenderingFlagsEXT { +impl fmt::Display for SemaphoreImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DeviceQueueCreateFlags { +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectEntryUsageFlagsNVX { ->>>>>>> Implement extension chaining +impl fmt::Display for AccelerationStructureTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; display_flags(f, KNOWN, self.0) } } -<<<<<<< HEAD -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), -======= -impl fmt::Display for TessellationDomainOrigin { +impl fmt::Display for PresentModeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), ->>>>>>> Implement extension chaining - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), -======= -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), _ => None, }; if let Some(x) = name { @@ -58934,7 +60304,6 @@ impl fmt::Display for DebugReportObjectTypeEXT { Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), ->>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -58944,386 +60313,6 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { -======= -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { ->>>>>>> Implement extension chaining - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for DebugReportFlagsEXT { -======= -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TRIANGLES => Some("TRIANGLES"), - Self::AABBS => Some("AABBS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BuildAccelerationStructureFlagsNV { ->>>>>>> Implement extension chaining - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), -======= -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for PhysicalDeviceType { -======= -impl fmt::Display for DescriptorType { ->>>>>>> Implement extension chaining - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), -======= -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TimeDomainEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEVICE => Some("DEVICE"), - Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), - Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), - Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), -======= impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59359,6 +60348,8 @@ impl fmt::Display for PipelineStageFlags { (PipelineStageFlags::HOST.0, "HOST"), (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), + (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), ( PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, "TRANSFORM_FEEDBACK_EXT", @@ -59385,33 +60376,32 @@ impl fmt::Display for PipelineStageFlags { ), (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), - (PipelineStageFlags::RESERVED_23_EXT.0, "RESERVED_23_EXT"), + ( + PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageLayout { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } ->>>>>>> Implement extension chaining + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), _ => None, }; if let Some(x) = name { @@ -59421,15 +60411,38 @@ impl fmt::Display for ImageLayout { } } } -<<<<<<< HEAD -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ -======= -impl fmt::Display for ValidationCacheHeaderVersionEXT { + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), _ => None, }; if let Some(x) = name { @@ -59439,50 +60452,190 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { +impl fmt::Display for ShadingRatePaletteEntryNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for ShaderStageFlags { +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", ), ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), - (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), - (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), - (ShaderStageFlags::MISS_NV.0, "MISS_NV"), - (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), - (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), - (ShaderStageFlags::TASK_NV.0, "TASK_NV"), - (ShaderStageFlags::MESH_NV.0, "MESH_NV"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SemaphoreImportFlags { +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + ( + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SurfaceCounterFlagsEXT { +impl fmt::Display for VendorId { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; display_flags(f, KNOWN, self.0) } } @@ -59492,39 +60645,200 @@ impl fmt::Display for SparseMemoryBindFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESERVED_8 => Some("RESERVED_8"), + Self::RESERVED_4 => Some("RESERVED_4"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ->>>>>>> Implement extension chaining ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", ), ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -<<<<<<< HEAD -impl fmt::Display for PeerMemoryFeatureFlags { +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CopyAccelerationStructureModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), -======= + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59792,55 +61106,18 @@ impl fmt::Display for Format { } } } -impl fmt::Display for SampleCountFlags { +impl fmt::Display for FormatFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), ->>>>>>> Implement extension chaining - ]; + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; display_flags(f, KNOWN, self.0) } } -<<<<<<< HEAD -impl fmt::Display for ConditionalRenderingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", -======= -impl fmt::Display for RasterizationOrderAMD { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), _ => None, }; if let Some(x) = name { @@ -59850,31 +61127,17 @@ impl fmt::Display for RasterizationOrderAMD { } } } -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", ->>>>>>> Implement extension chaining - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { +impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), _ => None, }; if let Some(x) = name { @@ -59884,26 +61147,11 @@ impl fmt::Display for PresentModeKHR { } } } -<<<<<<< HEAD -impl fmt::Display for LogicOp { +impl fmt::Display for AttachmentStoreOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), _ => None, }; if let Some(x) = name { @@ -59913,188 +61161,19 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for CommandPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), -======= -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RenderPassCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RayTracingShaderGroupTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for ValidationFeatureEnableEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GPU_ASSISTED => Some("GPU_ASSISTED"), - Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BuildAccelerationStructureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, - "ALLOW_UPDATE", - ), - ( - BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, - "ALLOW_COMPACTION", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, - "PREFER_FAST_TRACE", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, - "PREFER_FAST_BUILD", - ), - ( - BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, - "LOW_MEMORY", - ), -======= -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - (ImageUsageFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"), ->>>>>>> Implement extension chaining - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), -======= impl fmt::Display for TimeDomainEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -60102,7 +61181,6 @@ impl fmt::Display for TimeDomainEXT { Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), ->>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -60112,45 +61190,126 @@ impl fmt::Display for TimeDomainEXT { } } } -<<<<<<< HEAD -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), ]; display_flags(f, KNOWN, self.0) } } -======= ->>>>>>> Implement extension chaining -impl fmt::Display for SparseImageFormatFlags { +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", -<<<<<<< HEAD - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), ]; display_flags(f, KNOWN, self.0) } @@ -60181,12 +61340,6 @@ impl fmt::Display for ImageCreateFlags { ( ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, "BLOCK_TEXEL_VIEW_COMPATIBLE", -======= - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", ->>>>>>> Implement extension chaining ), (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), (ImageCreateFlags::PROTECTED.0, "PROTECTED"), @@ -60195,46 +61348,53 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } -<<<<<<< HEAD -impl fmt::Display for SampleCountFlags { +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryType { +impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::RESERVED_8 => Some("RESERVED_8"), - Self::RESERVED_4 => Some("RESERVED_4"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") } -======= -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), ->>>>>>> Implement extension chaining _ => None, }; if let Some(x) = name { @@ -60244,81 +61404,25 @@ impl fmt::Display for ValidationCheckEXT { } } } -<<<<<<< HEAD -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { +impl fmt::Display for GeometryTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), -======= -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), ->>>>>>> Implement extension chaining + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), _ => None, }; if let Some(x) = name { @@ -60328,17 +61432,12 @@ impl fmt::Display for SystemAllocationScope { } } } -impl fmt::Display for ViewportCoordinateSwizzleNV { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -60348,297 +61447,6 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -<<<<<<< HEAD -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), -======= -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), -======= -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), ->>>>>>> Implement extension chaining - ]; - display_flags(f, KNOWN, self.0) - } -} -<<<<<<< HEAD -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), -======= -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), -======= -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), ->>>>>>> Implement extension chaining - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -<<<<<<< HEAD -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), -======= -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), ->>>>>>> Implement extension chaining - ]; - display_flags(f, KNOWN, self.0) - } -} pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags; diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 2875c95..34c39fa 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1594,7 +1594,11 @@ pub fn derive_setters( // We only implement a next methods for root create infos let next_function = if has_next && next_extends.is_none() { quote! { - /// Prepend + /// Prepends the given extension struct between the root and the first pointer. This + /// method only exists on create infos that can be passed to a function directly. Only + /// valid extension structs can be pushed into the chain. + /// If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the + /// chain will look like `A -> D -> B -> C`. pub fn push_next(mut self, next: &'a mut T) -> #name_builder<'a> { unsafe{ let next_ptr = next.as_ptr_mut(); From d6a6aa310e65c5d2dec8d46346ab114b57b737d3 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Thu, 28 Feb 2019 10:14:40 +0100 Subject: [PATCH 08/21] Update experimental AMD extension --- ash/src/extensions/experimental/amd.rs | 31 +++++++++++++++++++++----- 1 file changed, 25 insertions(+), 6 deletions(-) diff --git a/ash/src/extensions/experimental/amd.rs b/ash/src/extensions/experimental/amd.rs index 76f4f5b..1407280 100644 --- a/ash/src/extensions/experimental/amd.rs +++ b/ash/src/extensions/experimental/amd.rs @@ -208,8 +208,14 @@ pub struct PhysicalDeviceGpaPropertiesAmdBuilder<'a> { inner: PhysicalDeviceGpaPropertiesAmd, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceGpaPropertiesAmd {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGpaPropertiesAmd {} +pub unsafe trait ExtendsPhysicalDeviceGpaPropertiesAmd { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGpaPropertiesAmd { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceGpaPropertiesAmdBuilder<'a> { type Target = PhysicalDeviceGpaPropertiesAmd; fn deref(&self) -> &Self::Target { @@ -648,8 +654,14 @@ pub struct PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { inner: PhysicalDeviceWaveLimitPropertiesAmd, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceWaveLimitPropertiesAmd {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceWaveLimitPropertiesAmd {} +pub unsafe trait ExtendsPhysicalDeviceWaveLimitPropertiesAmd { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceWaveLimitPropertiesAmd { + unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { + ::std::mem::transmute(self) + } +} impl<'a> ::std::ops::Deref for PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { type Target = PhysicalDeviceWaveLimitPropertiesAmd; fn deref(&self) -> &Self::Target { @@ -657,11 +669,18 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { } } impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { - pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> + pub fn push_next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> where T: ExtendsPhysicalDeviceWaveLimitPropertiesAmd, { - self.inner.p_next = next as *mut T as *mut c_void; + unsafe { + let next_ptr = next.as_ptr_mut(); + (*next_ptr).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } pub fn build(self) -> PhysicalDeviceWaveLimitPropertiesAmd { From 38fe16f6c7c2a02d7b5cfb5ea4e13da75a80fafb Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 3 Mar 2019 14:33:19 +0100 Subject: [PATCH 09/21] Use repr transparent for builders --- ash/src/extensions/experimental/amd.rs | 10 +- ash/src/vk.rs | 7013 ++++++++++-------------- generator/src/lib.rs | 10 +- 3 files changed, 2961 insertions(+), 4072 deletions(-) diff --git a/ash/src/extensions/experimental/amd.rs b/ash/src/extensions/experimental/amd.rs index 1407280..08f0f8d 100644 --- a/ash/src/extensions/experimental/amd.rs +++ b/ash/src/extensions/experimental/amd.rs @@ -209,12 +209,8 @@ pub struct PhysicalDeviceGpaPropertiesAmdBuilder<'a> { marker: ::std::marker::PhantomData<&'a ()>, } pub unsafe trait ExtendsPhysicalDeviceGpaPropertiesAmd { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; } unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGpaPropertiesAmd { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PhysicalDeviceGpaPropertiesAmdBuilder<'a> { type Target = PhysicalDeviceGpaPropertiesAmd; @@ -655,12 +651,8 @@ pub struct PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { marker: ::std::marker::PhantomData<&'a ()>, } pub unsafe trait ExtendsPhysicalDeviceWaveLimitPropertiesAmd { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; } unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceWaveLimitPropertiesAmd { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { type Target = PhysicalDeviceWaveLimitPropertiesAmd; @@ -677,7 +669,7 @@ impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { T: ExtendsPhysicalDeviceWaveLimitPropertiesAmd, { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut _ as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } diff --git a/ash/src/vk.rs b/ash/src/vk.rs index d858dea..c3b9639 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -7629,6 +7629,7 @@ impl Offset2D { } } } +#[repr(transparent)] pub struct Offset2DBuilder<'a> { inner: Offset2D, marker: ::std::marker::PhantomData<&'a ()>, @@ -7672,6 +7673,7 @@ impl Offset3D { } } } +#[repr(transparent)] pub struct Offset3DBuilder<'a> { inner: Offset3D, marker: ::std::marker::PhantomData<&'a ()>, @@ -7718,6 +7720,7 @@ impl Extent2D { } } } +#[repr(transparent)] pub struct Extent2DBuilder<'a> { inner: Extent2D, marker: ::std::marker::PhantomData<&'a ()>, @@ -7761,6 +7764,7 @@ impl Extent3D { } } } +#[repr(transparent)] pub struct Extent3DBuilder<'a> { inner: Extent3D, marker: ::std::marker::PhantomData<&'a ()>, @@ -7811,6 +7815,7 @@ impl Viewport { } } } +#[repr(transparent)] pub struct ViewportBuilder<'a> { inner: Viewport, marker: ::std::marker::PhantomData<&'a ()>, @@ -7869,6 +7874,7 @@ impl Rect2D { } } } +#[repr(transparent)] pub struct Rect2DBuilder<'a> { inner: Rect2D, marker: ::std::marker::PhantomData<&'a ()>, @@ -7912,6 +7918,7 @@ impl ClearRect { } } } +#[repr(transparent)] pub struct ClearRectBuilder<'a> { inner: ClearRect, marker: ::std::marker::PhantomData<&'a ()>, @@ -7960,6 +7967,7 @@ impl ComponentMapping { } } } +#[repr(transparent)] pub struct ComponentMappingBuilder<'a> { inner: ComponentMapping, marker: ::std::marker::PhantomData<&'a ()>, @@ -8049,6 +8057,7 @@ impl PhysicalDeviceProperties { } } } +#[repr(transparent)] pub struct PhysicalDevicePropertiesBuilder<'a> { inner: PhysicalDeviceProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -8149,6 +8158,7 @@ impl ExtensionProperties { } } } +#[repr(transparent)] pub struct ExtensionPropertiesBuilder<'a> { inner: ExtensionProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -8220,6 +8230,7 @@ impl LayerProperties { } } } +#[repr(transparent)] pub struct LayerPropertiesBuilder<'a> { inner: LayerProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -8297,13 +8308,12 @@ impl ApplicationInfo { } } } +#[repr(transparent)] pub struct ApplicationInfoBuilder<'a> { inner: ApplicationInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsApplicationInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsApplicationInfo {} impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> { type Target = ApplicationInfo; fn deref(&self) -> &Self::Target { @@ -8349,7 +8359,7 @@ impl<'a> ApplicationInfoBuilder<'a> { next: &'a mut T, ) -> ApplicationInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -8413,6 +8423,7 @@ impl AllocationCallbacks { } } } +#[repr(transparent)] pub struct AllocationCallbacksBuilder<'a> { inner: AllocationCallbacks, marker: ::std::marker::PhantomData<&'a ()>, @@ -8499,13 +8510,12 @@ impl DeviceQueueCreateInfo { } } } +#[repr(transparent)] pub struct DeviceQueueCreateInfoBuilder<'a> { inner: DeviceQueueCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceQueueCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDeviceQueueCreateInfo {} impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> { type Target = DeviceQueueCreateInfo; fn deref(&self) -> &Self::Target { @@ -8547,7 +8557,7 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> { next: &'a mut T, ) -> DeviceQueueCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -8595,13 +8605,12 @@ impl DeviceCreateInfo { } } } +#[repr(transparent)] pub struct DeviceCreateInfoBuilder<'a> { inner: DeviceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDeviceCreateInfo {} impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> { type Target = DeviceCreateInfo; fn deref(&self) -> &Self::Target { @@ -8659,7 +8668,7 @@ impl<'a> DeviceCreateInfoBuilder<'a> { next: &'a mut T, ) -> DeviceCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -8703,13 +8712,12 @@ impl InstanceCreateInfo { } } } +#[repr(transparent)] pub struct InstanceCreateInfoBuilder<'a> { inner: InstanceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsInstanceCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsInstanceCreateInfo {} impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> { type Target = InstanceCreateInfo; fn deref(&self) -> &Self::Target { @@ -8759,7 +8767,7 @@ impl<'a> InstanceCreateInfoBuilder<'a> { next: &'a mut T, ) -> InstanceCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -8785,6 +8793,7 @@ impl QueueFamilyProperties { } } } +#[repr(transparent)] pub struct QueueFamilyPropertiesBuilder<'a> { inner: QueueFamilyProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -8853,6 +8862,7 @@ impl PhysicalDeviceMemoryProperties { } } } +#[repr(transparent)] pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> { inner: PhysicalDeviceMemoryProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -8927,13 +8937,12 @@ impl MemoryAllocateInfo { } } } +#[repr(transparent)] pub struct MemoryAllocateInfoBuilder<'a> { inner: MemoryAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryAllocateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryAllocateInfo {} impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> { type Target = MemoryAllocateInfo; fn deref(&self) -> &Self::Target { @@ -8964,7 +8973,7 @@ impl<'a> MemoryAllocateInfoBuilder<'a> { next: &'a mut T, ) -> MemoryAllocateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -8989,6 +8998,7 @@ impl MemoryRequirements { } } } +#[repr(transparent)] pub struct MemoryRequirementsBuilder<'a> { inner: MemoryRequirements, marker: ::std::marker::PhantomData<&'a ()>, @@ -9036,6 +9046,7 @@ impl SparseImageFormatProperties { } } } +#[repr(transparent)] pub struct SparseImageFormatPropertiesBuilder<'a> { inner: SparseImageFormatProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -9094,6 +9105,7 @@ impl SparseImageMemoryRequirements { } } } +#[repr(transparent)] pub struct SparseImageMemoryRequirementsBuilder<'a> { inner: SparseImageMemoryRequirements, marker: ::std::marker::PhantomData<&'a ()>, @@ -9163,6 +9175,7 @@ impl MemoryType { } } } +#[repr(transparent)] pub struct MemoryTypeBuilder<'a> { inner: MemoryType, marker: ::std::marker::PhantomData<&'a ()>, @@ -9205,6 +9218,7 @@ impl MemoryHeap { } } } +#[repr(transparent)] pub struct MemoryHeapBuilder<'a> { inner: MemoryHeap, marker: ::std::marker::PhantomData<&'a ()>, @@ -9261,13 +9275,12 @@ impl MappedMemoryRange { } } } +#[repr(transparent)] pub struct MappedMemoryRangeBuilder<'a> { inner: MappedMemoryRange, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMappedMemoryRange { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMappedMemoryRange {} impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> { type Target = MappedMemoryRange; fn deref(&self) -> &Self::Target { @@ -9302,7 +9315,7 @@ impl<'a> MappedMemoryRangeBuilder<'a> { next: &'a mut T, ) -> MappedMemoryRangeBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -9327,6 +9340,7 @@ impl FormatProperties { } } } +#[repr(transparent)] pub struct FormatPropertiesBuilder<'a> { inner: FormatProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -9385,6 +9399,7 @@ impl ImageFormatProperties { } } } +#[repr(transparent)] pub struct ImageFormatPropertiesBuilder<'a> { inner: ImageFormatProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -9446,6 +9461,7 @@ impl DescriptorBufferInfo { } } } +#[repr(transparent)] pub struct DescriptorBufferInfoBuilder<'a> { inner: DescriptorBufferInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -9493,6 +9509,7 @@ impl DescriptorImageInfo { } } } +#[repr(transparent)] pub struct DescriptorImageInfoBuilder<'a> { inner: DescriptorImageInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -9563,13 +9580,12 @@ impl WriteDescriptorSet { } } } +#[repr(transparent)] pub struct WriteDescriptorSetBuilder<'a> { inner: WriteDescriptorSet, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWriteDescriptorSet { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsWriteDescriptorSet {} impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> { type Target = WriteDescriptorSet; fn deref(&self) -> &Self::Target { @@ -9635,7 +9651,7 @@ impl<'a> WriteDescriptorSetBuilder<'a> { next: &'a mut T, ) -> WriteDescriptorSetBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -9681,13 +9697,12 @@ impl CopyDescriptorSet { } } } +#[repr(transparent)] pub struct CopyDescriptorSetBuilder<'a> { inner: CopyDescriptorSet, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyDescriptorSet { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCopyDescriptorSet {} impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> { type Target = CopyDescriptorSet; fn deref(&self) -> &Self::Target { @@ -9738,7 +9753,7 @@ impl<'a> CopyDescriptorSetBuilder<'a> { next: &'a mut T, ) -> CopyDescriptorSetBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -9782,13 +9797,12 @@ impl BufferCreateInfo { } } } +#[repr(transparent)] pub struct BufferCreateInfoBuilder<'a> { inner: BufferCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBufferCreateInfo {} impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> { type Target = BufferCreateInfo; fn deref(&self) -> &Self::Target { @@ -9835,7 +9849,7 @@ impl<'a> BufferCreateInfoBuilder<'a> { next: &'a mut T, ) -> BufferCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -9877,13 +9891,12 @@ impl BufferViewCreateInfo { } } } +#[repr(transparent)] pub struct BufferViewCreateInfoBuilder<'a> { inner: BufferViewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferViewCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBufferViewCreateInfo {} impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { type Target = BufferViewCreateInfo; fn deref(&self) -> &Self::Target { @@ -9926,7 +9939,7 @@ impl<'a> BufferViewCreateInfoBuilder<'a> { next: &'a mut T, ) -> BufferViewCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -9951,6 +9964,7 @@ impl ImageSubresource { } } } +#[repr(transparent)] pub struct ImageSubresourceBuilder<'a> { inner: ImageSubresource, marker: ::std::marker::PhantomData<&'a ()>, @@ -9999,6 +10013,7 @@ impl ImageSubresourceLayers { } } } +#[repr(transparent)] pub struct ImageSubresourceLayersBuilder<'a> { inner: ImageSubresourceLayers, marker: ::std::marker::PhantomData<&'a ()>, @@ -10055,6 +10070,7 @@ impl ImageSubresourceRange { } } } +#[repr(transparent)] pub struct ImageSubresourceRangeBuilder<'a> { inner: ImageSubresourceRange, marker: ::std::marker::PhantomData<&'a ()>, @@ -10124,13 +10140,12 @@ impl MemoryBarrier { } } } +#[repr(transparent)] pub struct MemoryBarrierBuilder<'a> { inner: MemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryBarrier { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryBarrier {} impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> { type Target = MemoryBarrier; fn deref(&self) -> &Self::Target { @@ -10161,7 +10176,7 @@ impl<'a> MemoryBarrierBuilder<'a> { next: &'a mut T, ) -> MemoryBarrierBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -10207,13 +10222,12 @@ impl BufferMemoryBarrier { } } } +#[repr(transparent)] pub struct BufferMemoryBarrierBuilder<'a> { inner: BufferMemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferMemoryBarrier { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBufferMemoryBarrier {} impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> { type Target = BufferMemoryBarrier; fn deref(&self) -> &Self::Target { @@ -10276,7 +10290,7 @@ impl<'a> BufferMemoryBarrierBuilder<'a> { next: &'a mut T, ) -> BufferMemoryBarrierBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -10324,13 +10338,12 @@ impl ImageMemoryBarrier { } } } +#[repr(transparent)] pub struct ImageMemoryBarrierBuilder<'a> { inner: ImageMemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageMemoryBarrier { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImageMemoryBarrier {} impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> { type Target = ImageMemoryBarrier; fn deref(&self) -> &Self::Target { @@ -10400,7 +10413,7 @@ impl<'a> ImageMemoryBarrierBuilder<'a> { next: &'a mut T, ) -> ImageMemoryBarrierBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -10458,13 +10471,12 @@ impl ImageCreateInfo { } } } +#[repr(transparent)] pub struct ImageCreateInfoBuilder<'a> { inner: ImageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImageCreateInfo {} impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> { type Target = ImageCreateInfo; fn deref(&self) -> &Self::Target { @@ -10539,7 +10551,7 @@ impl<'a> ImageCreateInfoBuilder<'a> { next: &'a mut T, ) -> ImageCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -10566,6 +10578,7 @@ impl SubresourceLayout { } } } +#[repr(transparent)] pub struct SubresourceLayoutBuilder<'a> { inner: SubresourceLayout, marker: ::std::marker::PhantomData<&'a ()>, @@ -10640,13 +10653,12 @@ impl ImageViewCreateInfo { } } } +#[repr(transparent)] pub struct ImageViewCreateInfoBuilder<'a> { inner: ImageViewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageViewCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImageViewCreateInfo {} impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> { type Target = ImageViewCreateInfo; fn deref(&self) -> &Self::Target { @@ -10696,7 +10708,7 @@ impl<'a> ImageViewCreateInfoBuilder<'a> { next: &'a mut T, ) -> ImageViewCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -10721,6 +10733,7 @@ impl BufferCopy { } } } +#[repr(transparent)] pub struct BufferCopyBuilder<'a> { inner: BufferCopy, marker: ::std::marker::PhantomData<&'a ()>, @@ -10770,6 +10783,7 @@ impl SparseMemoryBind { } } } +#[repr(transparent)] pub struct SparseMemoryBindBuilder<'a> { inner: SparseMemoryBind, marker: ::std::marker::PhantomData<&'a ()>, @@ -10828,6 +10842,7 @@ impl SparseImageMemoryBind { } } } +#[repr(transparent)] pub struct SparseImageMemoryBindBuilder<'a> { inner: SparseImageMemoryBind, marker: ::std::marker::PhantomData<&'a ()>, @@ -10899,6 +10914,7 @@ impl SparseBufferMemoryBindInfo { } } } +#[repr(transparent)] pub struct SparseBufferMemoryBindInfoBuilder<'a> { inner: SparseBufferMemoryBindInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -10952,6 +10968,7 @@ impl SparseImageOpaqueMemoryBindInfo { } } } +#[repr(transparent)] pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> { inner: SparseImageOpaqueMemoryBindInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -11008,6 +11025,7 @@ impl SparseImageMemoryBindInfo { } } } +#[repr(transparent)] pub struct SparseImageMemoryBindInfoBuilder<'a> { inner: SparseImageMemoryBindInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -11082,13 +11100,12 @@ impl BindSparseInfo { } } } +#[repr(transparent)] pub struct BindSparseInfoBuilder<'a> { inner: BindSparseInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindSparseInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBindSparseInfo {} impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> { type Target = BindSparseInfo; fn deref(&self) -> &Self::Target { @@ -11151,7 +11168,7 @@ impl<'a> BindSparseInfoBuilder<'a> { next: &'a mut T, ) -> BindSparseInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -11178,6 +11195,7 @@ impl ImageCopy { } } } +#[repr(transparent)] pub struct ImageCopyBuilder<'a> { inner: ImageCopy, marker: ::std::marker::PhantomData<&'a ()>, @@ -11250,6 +11268,7 @@ impl ImageBlit { } } } +#[repr(transparent)] pub struct ImageBlitBuilder<'a> { inner: ImageBlit, marker: ::std::marker::PhantomData<&'a ()>, @@ -11310,6 +11329,7 @@ impl BufferImageCopy { } } } +#[repr(transparent)] pub struct BufferImageCopyBuilder<'a> { inner: BufferImageCopy, marker: ::std::marker::PhantomData<&'a ()>, @@ -11374,6 +11394,7 @@ impl ImageResolve { } } } +#[repr(transparent)] pub struct ImageResolveBuilder<'a> { inner: ImageResolve, marker: ::std::marker::PhantomData<&'a ()>, @@ -11448,13 +11469,12 @@ impl ShaderModuleCreateInfo { } } } +#[repr(transparent)] pub struct ShaderModuleCreateInfoBuilder<'a> { inner: ShaderModuleCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsShaderModuleCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsShaderModuleCreateInfo {} impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> { type Target = ShaderModuleCreateInfo; fn deref(&self) -> &Self::Target { @@ -11486,7 +11506,7 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> { next: &'a mut T, ) -> ShaderModuleCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -11524,6 +11544,7 @@ impl DescriptorSetLayoutBinding { } } } +#[repr(transparent)] pub struct DescriptorSetLayoutBindingBuilder<'a> { inner: DescriptorSetLayoutBinding, marker: ::std::marker::PhantomData<&'a ()>, @@ -11605,13 +11626,12 @@ impl DescriptorSetLayoutCreateInfo { } } } +#[repr(transparent)] pub struct DescriptorSetLayoutCreateInfoBuilder<'a> { inner: DescriptorSetLayoutCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {} impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> { type Target = DescriptorSetLayoutCreateInfo; fn deref(&self) -> &Self::Target { @@ -11649,7 +11669,7 @@ impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { next: &'a mut T, ) -> DescriptorSetLayoutCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -11673,6 +11693,7 @@ impl DescriptorPoolSize { } } } +#[repr(transparent)] pub struct DescriptorPoolSizeBuilder<'a> { inner: DescriptorPoolSize, marker: ::std::marker::PhantomData<&'a ()>, @@ -11731,13 +11752,12 @@ impl DescriptorPoolCreateInfo { } } } +#[repr(transparent)] pub struct DescriptorPoolCreateInfoBuilder<'a> { inner: DescriptorPoolCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorPoolCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDescriptorPoolCreateInfo {} impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> { type Target = DescriptorPoolCreateInfo; fn deref(&self) -> &Self::Target { @@ -11779,7 +11799,7 @@ impl<'a> DescriptorPoolCreateInfoBuilder<'a> { next: &'a mut T, ) -> DescriptorPoolCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -11817,13 +11837,12 @@ impl DescriptorSetAllocateInfo { } } } +#[repr(transparent)] pub struct DescriptorSetAllocateInfoBuilder<'a> { inner: DescriptorSetAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetAllocateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDescriptorSetAllocateInfo {} impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> { type Target = DescriptorSetAllocateInfo; fn deref(&self) -> &Self::Target { @@ -11861,7 +11880,7 @@ impl<'a> DescriptorSetAllocateInfoBuilder<'a> { next: &'a mut T, ) -> DescriptorSetAllocateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -11886,6 +11905,7 @@ impl SpecializationMapEntry { } } } +#[repr(transparent)] pub struct SpecializationMapEntryBuilder<'a> { inner: SpecializationMapEntry, marker: ::std::marker::PhantomData<&'a ()>, @@ -11944,6 +11964,7 @@ impl SpecializationInfo { } } } +#[repr(transparent)] pub struct SpecializationInfoBuilder<'a> { inner: SpecializationInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -12009,13 +12030,12 @@ impl PipelineShaderStageCreateInfo { } } } +#[repr(transparent)] pub struct PipelineShaderStageCreateInfoBuilder<'a> { inner: PipelineShaderStageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineShaderStageCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineShaderStageCreateInfo {} impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> { type Target = PipelineShaderStageCreateInfo; fn deref(&self) -> &Self::Target { @@ -12064,7 +12084,7 @@ impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineShaderStageCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12106,13 +12126,12 @@ impl ComputePipelineCreateInfo { } } } +#[repr(transparent)] pub struct ComputePipelineCreateInfoBuilder<'a> { inner: ComputePipelineCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsComputePipelineCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsComputePipelineCreateInfo {} impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> { type Target = ComputePipelineCreateInfo; fn deref(&self) -> &Self::Target { @@ -12164,7 +12183,7 @@ impl<'a> ComputePipelineCreateInfoBuilder<'a> { next: &'a mut T, ) -> ComputePipelineCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12189,6 +12208,7 @@ impl VertexInputBindingDescription { } } } +#[repr(transparent)] pub struct VertexInputBindingDescriptionBuilder<'a> { inner: VertexInputBindingDescription, marker: ::std::marker::PhantomData<&'a ()>, @@ -12240,6 +12260,7 @@ impl VertexInputAttributeDescription { } } } +#[repr(transparent)] pub struct VertexInputAttributeDescriptionBuilder<'a> { inner: VertexInputAttributeDescription, marker: ::std::marker::PhantomData<&'a ()>, @@ -12308,13 +12329,12 @@ impl PipelineVertexInputStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineVertexInputStateCreateInfoBuilder<'a> { inner: PipelineVertexInputStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> { type Target = PipelineVertexInputStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -12360,7 +12380,7 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12398,13 +12418,12 @@ impl PipelineInputAssemblyStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> { inner: PipelineInputAssemblyStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineInputAssemblyStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineInputAssemblyStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> { type Target = PipelineInputAssemblyStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -12448,7 +12467,7 @@ impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12484,13 +12503,12 @@ impl PipelineTessellationStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineTessellationStateCreateInfoBuilder<'a> { inner: PipelineTessellationStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineTessellationStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> { type Target = PipelineTessellationStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -12527,7 +12545,7 @@ impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineTessellationStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12569,13 +12587,12 @@ impl PipelineViewportStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineViewportStateCreateInfoBuilder<'a> { inner: PipelineViewportStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineViewportStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineViewportStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> { type Target = PipelineViewportStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -12635,7 +12652,7 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineViewportStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12689,13 +12706,12 @@ impl PipelineRasterizationStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineRasterizationStateCreateInfoBuilder<'a> { inner: PipelineRasterizationStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> { type Target = PipelineRasterizationStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -12795,7 +12811,7 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12841,13 +12857,12 @@ impl PipelineMultisampleStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineMultisampleStateCreateInfoBuilder<'a> { inner: PipelineMultisampleStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> { type Target = PipelineMultisampleStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -12919,7 +12934,7 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -12949,6 +12964,7 @@ impl PipelineColorBlendAttachmentState { } } } +#[repr(transparent)] pub struct PipelineColorBlendAttachmentStateBuilder<'a> { inner: PipelineColorBlendAttachmentState, marker: ::std::marker::PhantomData<&'a ()>, @@ -13059,13 +13075,12 @@ impl PipelineColorBlendStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineColorBlendStateCreateInfoBuilder<'a> { inner: PipelineColorBlendStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> { type Target = PipelineColorBlendStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -13121,7 +13136,7 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -13159,13 +13174,12 @@ impl PipelineDynamicStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineDynamicStateCreateInfoBuilder<'a> { inner: PipelineDynamicStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineDynamicStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineDynamicStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> { type Target = PipelineDynamicStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -13203,7 +13217,7 @@ impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineDynamicStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -13232,6 +13246,7 @@ impl StencilOpState { } } } +#[repr(transparent)] pub struct StencilOpStateBuilder<'a> { inner: StencilOpState, marker: ::std::marker::PhantomData<&'a ()>, @@ -13322,13 +13337,12 @@ impl PipelineDepthStencilStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> { inner: PipelineDepthStencilStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineDepthStencilStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineDepthStencilStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> { type Target = PipelineDepthStencilStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -13418,7 +13432,7 @@ impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -13484,13 +13498,12 @@ impl GraphicsPipelineCreateInfo { } } } +#[repr(transparent)] pub struct GraphicsPipelineCreateInfoBuilder<'a> { inner: GraphicsPipelineCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGraphicsPipelineCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsGraphicsPipelineCreateInfo {} impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> { type Target = GraphicsPipelineCreateInfo; fn deref(&self) -> &Self::Target { @@ -13614,7 +13627,7 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { next: &'a mut T, ) -> GraphicsPipelineCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -13652,13 +13665,12 @@ impl PipelineCacheCreateInfo { } } } +#[repr(transparent)] pub struct PipelineCacheCreateInfoBuilder<'a> { inner: PipelineCacheCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineCacheCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineCacheCreateInfo {} impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> { type Target = PipelineCacheCreateInfo; fn deref(&self) -> &Self::Target { @@ -13690,7 +13702,7 @@ impl<'a> PipelineCacheCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineCacheCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -13715,6 +13727,7 @@ impl PushConstantRange { } } } +#[repr(transparent)] pub struct PushConstantRangeBuilder<'a> { inner: PushConstantRange, marker: ::std::marker::PhantomData<&'a ()>, @@ -13779,13 +13792,12 @@ impl PipelineLayoutCreateInfo { } } } +#[repr(transparent)] pub struct PipelineLayoutCreateInfoBuilder<'a> { inner: PipelineLayoutCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineLayoutCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPipelineLayoutCreateInfo {} impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> { type Target = PipelineLayoutCreateInfo; fn deref(&self) -> &Self::Target { @@ -13831,7 +13843,7 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> { next: &'a mut T, ) -> PipelineLayoutCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -13895,13 +13907,12 @@ impl SamplerCreateInfo { } } } +#[repr(transparent)] pub struct SamplerCreateInfoBuilder<'a> { inner: SamplerCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSamplerCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSamplerCreateInfo {} impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> { type Target = SamplerCreateInfo; fn deref(&self) -> &Self::Target { @@ -14000,7 +14011,7 @@ impl<'a> SamplerCreateInfoBuilder<'a> { next: &'a mut T, ) -> SamplerCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -14036,13 +14047,12 @@ impl CommandPoolCreateInfo { } } } +#[repr(transparent)] pub struct CommandPoolCreateInfoBuilder<'a> { inner: CommandPoolCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandPoolCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCommandPoolCreateInfo {} impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> { type Target = CommandPoolCreateInfo; fn deref(&self) -> &Self::Target { @@ -14076,7 +14086,7 @@ impl<'a> CommandPoolCreateInfoBuilder<'a> { next: &'a mut T, ) -> CommandPoolCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -14114,13 +14124,12 @@ impl CommandBufferAllocateInfo { } } } +#[repr(transparent)] pub struct CommandBufferAllocateInfoBuilder<'a> { inner: CommandBufferAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferAllocateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCommandBufferAllocateInfo {} impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> { type Target = CommandBufferAllocateInfo; fn deref(&self) -> &Self::Target { @@ -14161,7 +14170,7 @@ impl<'a> CommandBufferAllocateInfoBuilder<'a> { next: &'a mut T, ) -> CommandBufferAllocateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -14205,13 +14214,12 @@ impl CommandBufferInheritanceInfo { } } } +#[repr(transparent)] pub struct CommandBufferInheritanceInfoBuilder<'a> { inner: CommandBufferInheritanceInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferInheritanceInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCommandBufferInheritanceInfo {} impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> { type Target = CommandBufferInheritanceInfo; fn deref(&self) -> &Self::Target { @@ -14273,7 +14281,7 @@ impl<'a> CommandBufferInheritanceInfoBuilder<'a> { next: &'a mut T, ) -> CommandBufferInheritanceInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -14309,13 +14317,12 @@ impl CommandBufferBeginInfo { } } } +#[repr(transparent)] pub struct CommandBufferBeginInfoBuilder<'a> { inner: CommandBufferBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferBeginInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCommandBufferBeginInfo {} impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> { type Target = CommandBufferBeginInfo; fn deref(&self) -> &Self::Target { @@ -14349,7 +14356,7 @@ impl<'a> CommandBufferBeginInfoBuilder<'a> { next: &'a mut T, ) -> CommandBufferBeginInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -14404,13 +14411,12 @@ impl RenderPassBeginInfo { } } } +#[repr(transparent)] pub struct RenderPassBeginInfoBuilder<'a> { inner: RenderPassBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassBeginInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsRenderPassBeginInfo {} impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> { type Target = RenderPassBeginInfo; fn deref(&self) -> &Self::Target { @@ -14453,7 +14459,7 @@ impl<'a> RenderPassBeginInfoBuilder<'a> { next: &'a mut T, ) -> RenderPassBeginInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -14489,6 +14495,7 @@ impl ClearDepthStencilValue { } } } +#[repr(transparent)] pub struct ClearDepthStencilValueBuilder<'a> { inner: ClearDepthStencilValue, marker: ::std::marker::PhantomData<&'a ()>, @@ -14552,6 +14559,7 @@ impl ClearAttachment { } } } +#[repr(transparent)] pub struct ClearAttachmentBuilder<'a> { inner: ClearAttachment, marker: ::std::marker::PhantomData<&'a ()>, @@ -14605,6 +14613,7 @@ impl AttachmentDescription { } } } +#[repr(transparent)] pub struct AttachmentDescriptionBuilder<'a> { inner: AttachmentDescription, marker: ::std::marker::PhantomData<&'a ()>, @@ -14684,6 +14693,7 @@ impl AttachmentReference { } } } +#[repr(transparent)] pub struct AttachmentReferenceBuilder<'a> { inner: AttachmentReference, marker: ::std::marker::PhantomData<&'a ()>, @@ -14750,6 +14760,7 @@ impl SubpassDescription { } } } +#[repr(transparent)] pub struct SubpassDescriptionBuilder<'a> { inner: SubpassDescription, marker: ::std::marker::PhantomData<&'a ()>, @@ -14839,6 +14850,7 @@ impl SubpassDependency { } } } +#[repr(transparent)] pub struct SubpassDependencyBuilder<'a> { inner: SubpassDependency, marker: ::std::marker::PhantomData<&'a ()>, @@ -14932,13 +14944,12 @@ impl RenderPassCreateInfo { } } } +#[repr(transparent)] pub struct RenderPassCreateInfoBuilder<'a> { inner: RenderPassCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsRenderPassCreateInfo {} impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> { type Target = RenderPassCreateInfo; fn deref(&self) -> &Self::Target { @@ -14989,7 +15000,7 @@ impl<'a> RenderPassCreateInfoBuilder<'a> { next: &'a mut T, ) -> RenderPassCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -15023,13 +15034,12 @@ impl EventCreateInfo { } } } +#[repr(transparent)] pub struct EventCreateInfoBuilder<'a> { inner: EventCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsEventCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsEventCreateInfo {} impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { type Target = EventCreateInfo; fn deref(&self) -> &Self::Target { @@ -15056,7 +15066,7 @@ impl<'a> EventCreateInfoBuilder<'a> { next: &'a mut T, ) -> EventCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -15090,13 +15100,12 @@ impl FenceCreateInfo { } } } +#[repr(transparent)] pub struct FenceCreateInfoBuilder<'a> { inner: FenceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsFenceCreateInfo {} impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> { type Target = FenceCreateInfo; fn deref(&self) -> &Self::Target { @@ -15123,7 +15132,7 @@ impl<'a> FenceCreateInfoBuilder<'a> { next: &'a mut T, ) -> FenceCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -15200,6 +15209,7 @@ impl PhysicalDeviceFeatures { } } } +#[repr(transparent)] pub struct PhysicalDeviceFeaturesBuilder<'a> { inner: PhysicalDeviceFeatures, marker: ::std::marker::PhantomData<&'a ()>, @@ -15585,6 +15595,7 @@ impl PhysicalDeviceSparseProperties { } } } +#[repr(transparent)] pub struct PhysicalDeviceSparsePropertiesBuilder<'a> { inner: PhysicalDeviceSparseProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -15871,6 +15882,7 @@ impl PhysicalDeviceLimits { } } } +#[repr(transparent)] pub struct PhysicalDeviceLimitsBuilder<'a> { inner: PhysicalDeviceLimits, marker: ::std::marker::PhantomData<&'a ()>, @@ -16660,13 +16672,12 @@ impl SemaphoreCreateInfo { } } } +#[repr(transparent)] pub struct SemaphoreCreateInfoBuilder<'a> { inner: SemaphoreCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSemaphoreCreateInfo {} impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> { type Target = SemaphoreCreateInfo; fn deref(&self) -> &Self::Target { @@ -16693,7 +16704,7 @@ impl<'a> SemaphoreCreateInfoBuilder<'a> { next: &'a mut T, ) -> SemaphoreCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -16733,13 +16744,12 @@ impl QueryPoolCreateInfo { } } } +#[repr(transparent)] pub struct QueryPoolCreateInfoBuilder<'a> { inner: QueryPoolCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsQueryPoolCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsQueryPoolCreateInfo {} impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> { type Target = QueryPoolCreateInfo; fn deref(&self) -> &Self::Target { @@ -16781,7 +16791,7 @@ impl<'a> QueryPoolCreateInfoBuilder<'a> { next: &'a mut T, ) -> QueryPoolCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -16827,13 +16837,12 @@ impl FramebufferCreateInfo { } } } +#[repr(transparent)] pub struct FramebufferCreateInfoBuilder<'a> { inner: FramebufferCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFramebufferCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsFramebufferCreateInfo {} impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> { type Target = FramebufferCreateInfo; fn deref(&self) -> &Self::Target { @@ -16881,7 +16890,7 @@ impl<'a> FramebufferCreateInfoBuilder<'a> { next: &'a mut T, ) -> FramebufferCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -16907,6 +16916,7 @@ impl DrawIndirectCommand { } } } +#[repr(transparent)] pub struct DrawIndirectCommandBuilder<'a> { inner: DrawIndirectCommand, marker: ::std::marker::PhantomData<&'a ()>, @@ -16960,6 +16970,7 @@ impl DrawIndexedIndirectCommand { } } } +#[repr(transparent)] pub struct DrawIndexedIndirectCommandBuilder<'a> { inner: DrawIndexedIndirectCommand, marker: ::std::marker::PhantomData<&'a ()>, @@ -17015,6 +17026,7 @@ impl DispatchIndirectCommand { } } } +#[repr(transparent)] pub struct DispatchIndirectCommandBuilder<'a> { inner: DispatchIndirectCommand, marker: ::std::marker::PhantomData<&'a ()>, @@ -17083,13 +17095,12 @@ impl SubmitInfo { } } } +#[repr(transparent)] pub struct SubmitInfoBuilder<'a> { inner: SubmitInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubmitInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSubmitInfo {} impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> { type Target = SubmitInfo; fn deref(&self) -> &Self::Target { @@ -17138,7 +17149,7 @@ impl<'a> SubmitInfoBuilder<'a> { #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> SubmitInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -17180,6 +17191,7 @@ impl DisplayPropertiesKHR { } } } +#[repr(transparent)] pub struct DisplayPropertiesKHRBuilder<'a> { inner: DisplayPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -17257,6 +17269,7 @@ impl DisplayPlanePropertiesKHR { } } } +#[repr(transparent)] pub struct DisplayPlanePropertiesKHRBuilder<'a> { inner: DisplayPlanePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -17305,6 +17318,7 @@ impl DisplayModeParametersKHR { } } } +#[repr(transparent)] pub struct DisplayModeParametersKHRBuilder<'a> { inner: DisplayModeParametersKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -17350,6 +17364,7 @@ impl DisplayModePropertiesKHR { } } } +#[repr(transparent)] pub struct DisplayModePropertiesKHRBuilder<'a> { inner: DisplayModePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -17410,13 +17425,12 @@ impl DisplayModeCreateInfoKHR { } } } +#[repr(transparent)] pub struct DisplayModeCreateInfoKHRBuilder<'a> { inner: DisplayModeCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayModeCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayModeCreateInfoKHR {} impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> { type Target = DisplayModeCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -17453,7 +17467,7 @@ impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> DisplayModeCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -17484,6 +17498,7 @@ impl DisplayPlaneCapabilitiesKHR { } } } +#[repr(transparent)] pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> { inner: DisplayPlaneCapabilitiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -17605,13 +17620,12 @@ impl DisplaySurfaceCreateInfoKHR { } } } +#[repr(transparent)] pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> { inner: DisplaySurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplaySurfaceCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplaySurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> { type Target = DisplaySurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -17684,7 +17698,7 @@ impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -17722,20 +17736,13 @@ impl DisplayPresentInfoKHR { } } } +#[repr(transparent)] pub struct DisplayPresentInfoKHRBuilder<'a> { inner: DisplayPresentInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {} impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> { type Target = DisplayPresentInfoKHR; fn deref(&self) -> &Self::Target { @@ -17786,6 +17793,7 @@ impl SurfaceCapabilitiesKHR { } } } +#[repr(transparent)] pub struct SurfaceCapabilitiesKHRBuilder<'a> { inner: SurfaceCapabilitiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -17893,13 +17901,12 @@ impl AndroidSurfaceCreateInfoKHR { } } } +#[repr(transparent)] pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> { inner: AndroidSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAndroidSurfaceCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAndroidSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> { type Target = AndroidSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -17933,7 +17940,7 @@ impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -17969,13 +17976,12 @@ impl ViSurfaceCreateInfoNN { } } } +#[repr(transparent)] pub struct ViSurfaceCreateInfoNNBuilder<'a> { inner: ViSurfaceCreateInfoNN, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsViSurfaceCreateInfoNN { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsViSurfaceCreateInfoNN {} impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> { type Target = ViSurfaceCreateInfoNN; fn deref(&self) -> &Self::Target { @@ -18006,7 +18012,7 @@ impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { next: &'a mut T, ) -> ViSurfaceCreateInfoNNBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18044,13 +18050,12 @@ impl WaylandSurfaceCreateInfoKHR { } } } +#[repr(transparent)] pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> { inner: WaylandSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWaylandSurfaceCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsWaylandSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> { type Target = WaylandSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -18088,7 +18093,7 @@ impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18126,13 +18131,12 @@ impl Win32SurfaceCreateInfoKHR { } } } +#[repr(transparent)] pub struct Win32SurfaceCreateInfoKHRBuilder<'a> { inner: Win32SurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWin32SurfaceCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsWin32SurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> { type Target = Win32SurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -18170,7 +18174,7 @@ impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> Win32SurfaceCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18208,13 +18212,12 @@ impl XlibSurfaceCreateInfoKHR { } } } +#[repr(transparent)] pub struct XlibSurfaceCreateInfoKHRBuilder<'a> { inner: XlibSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsXlibSurfaceCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsXlibSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> { type Target = XlibSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -18252,7 +18255,7 @@ impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> XlibSurfaceCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18290,13 +18293,12 @@ impl XcbSurfaceCreateInfoKHR { } } } +#[repr(transparent)] pub struct XcbSurfaceCreateInfoKHRBuilder<'a> { inner: XcbSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsXcbSurfaceCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsXcbSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> { type Target = XcbSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -18334,7 +18336,7 @@ impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> XcbSurfaceCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18370,13 +18372,12 @@ impl ImagePipeSurfaceCreateInfoFUCHSIA { } } } +#[repr(transparent)] pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { inner: ImagePipeSurfaceCreateInfoFUCHSIA, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImagePipeSurfaceCreateInfoFUCHSIA { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImagePipeSurfaceCreateInfoFUCHSIA {} impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { type Target = ImagePipeSurfaceCreateInfoFUCHSIA; fn deref(&self) -> &Self::Target { @@ -18413,7 +18414,7 @@ impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { next: &'a mut T, ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18437,6 +18438,7 @@ impl SurfaceFormatKHR { } } } +#[repr(transparent)] pub struct SurfaceFormatKHRBuilder<'a> { inner: SurfaceFormatKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -18519,13 +18521,12 @@ impl SwapchainCreateInfoKHR { } } } +#[repr(transparent)] pub struct SwapchainCreateInfoKHRBuilder<'a> { inner: SwapchainCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSwapchainCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSwapchainCreateInfoKHR {} impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> { type Target = SwapchainCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -18636,7 +18637,7 @@ impl<'a> SwapchainCreateInfoKHRBuilder<'a> { next: &'a mut T, ) -> SwapchainCreateInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18680,13 +18681,12 @@ impl PresentInfoKHR { } } } +#[repr(transparent)] pub struct PresentInfoKHRBuilder<'a> { inner: PresentInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPresentInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPresentInfoKHR {} impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> { type Target = PresentInfoKHR; fn deref(&self) -> &Self::Target { @@ -18732,7 +18732,7 @@ impl<'a> PresentInfoKHRBuilder<'a> { next: &'a mut T, ) -> PresentInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -18781,20 +18781,13 @@ impl DebugReportCallbackCreateInfoEXT { } } } +#[repr(transparent)] pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> { inner: DebugReportCallbackCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {} impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> { type Target = DebugReportCallbackCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -18858,20 +18851,13 @@ impl ValidationFlagsEXT { } } } +#[repr(transparent)] pub struct ValidationFlagsEXTBuilder<'a> { inner: ValidationFlagsEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {} impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> { type Target = ValidationFlagsEXT; fn deref(&self) -> &Self::Target { @@ -18926,20 +18912,13 @@ impl ValidationFeaturesEXT { } } } +#[repr(transparent)] pub struct ValidationFeaturesEXTBuilder<'a> { inner: ValidationFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {} impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> { type Target = ValidationFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -18996,6 +18975,7 @@ impl PipelineRasterizationStateRasterizationOrderAMD { } } } +#[repr(transparent)] pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { inner: PipelineRasterizationStateRasterizationOrderAMD, marker: ::std::marker::PhantomData<&'a ()>, @@ -19003,16 +18983,10 @@ pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationStateRasterizationOrderAMD { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { type Target = PipelineRasterizationStateRasterizationOrderAMD; @@ -19065,13 +19039,12 @@ impl DebugMarkerObjectNameInfoEXT { } } } +#[repr(transparent)] pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> { inner: DebugMarkerObjectNameInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerObjectNameInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDebugMarkerObjectNameInfoEXT {} impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> { type Target = DebugMarkerObjectNameInfoEXT; fn deref(&self) -> &Self::Target { @@ -19112,7 +19085,7 @@ impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { next: &'a mut T, ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -19154,13 +19127,12 @@ impl DebugMarkerObjectTagInfoEXT { } } } +#[repr(transparent)] pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> { inner: DebugMarkerObjectTagInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerObjectTagInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDebugMarkerObjectTagInfoEXT {} impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> { type Target = DebugMarkerObjectTagInfoEXT; fn deref(&self) -> &Self::Target { @@ -19203,7 +19175,7 @@ impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { next: &'a mut T, ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -19239,13 +19211,12 @@ impl DebugMarkerMarkerInfoEXT { } } } +#[repr(transparent)] pub struct DebugMarkerMarkerInfoEXTBuilder<'a> { inner: DebugMarkerMarkerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerMarkerInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDebugMarkerMarkerInfoEXT {} impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> { type Target = DebugMarkerMarkerInfoEXT; fn deref(&self) -> &Self::Target { @@ -19279,7 +19250,7 @@ impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { next: &'a mut T, ) -> DebugMarkerMarkerInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -19313,20 +19284,13 @@ impl DedicatedAllocationImageCreateInfoNV { } } } +#[repr(transparent)] pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> { inner: DedicatedAllocationImageCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {} impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> { type Target = DedicatedAllocationImageCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -19374,20 +19338,13 @@ impl DedicatedAllocationBufferCreateInfoNV { } } } +#[repr(transparent)] pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> { inner: DedicatedAllocationBufferCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {} impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { type Target = DedicatedAllocationBufferCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -19437,20 +19394,13 @@ impl DedicatedAllocationMemoryAllocateInfoNV { } } } +#[repr(transparent)] pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { inner: DedicatedAllocationMemoryAllocateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {} impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { type Target = DedicatedAllocationMemoryAllocateInfoNV; fn deref(&self) -> &Self::Target { @@ -19491,6 +19441,7 @@ impl ExternalImageFormatPropertiesNV { } } } +#[repr(transparent)] pub struct ExternalImageFormatPropertiesNVBuilder<'a> { inner: ExternalImageFormatPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -19563,20 +19514,13 @@ impl ExternalMemoryImageCreateInfoNV { } } } +#[repr(transparent)] pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> { inner: ExternalMemoryImageCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {} impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> { type Target = ExternalMemoryImageCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -19624,20 +19568,13 @@ impl ExportMemoryAllocateInfoNV { } } } +#[repr(transparent)] pub struct ExportMemoryAllocateInfoNVBuilder<'a> { inner: ExportMemoryAllocateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {} impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> { type Target = ExportMemoryAllocateInfoNV; fn deref(&self) -> &Self::Target { @@ -19687,20 +19624,13 @@ impl ImportMemoryWin32HandleInfoNV { } } } +#[repr(transparent)] pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> { inner: ImportMemoryWin32HandleInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {} impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> { type Target = ImportMemoryWin32HandleInfoNV; fn deref(&self) -> &Self::Target { @@ -19754,20 +19684,13 @@ impl ExportMemoryWin32HandleInfoNV { } } } +#[repr(transparent)] pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> { inner: ExportMemoryWin32HandleInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {} impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> { type Target = ExportMemoryWin32HandleInfoNV; fn deref(&self) -> &Self::Target { @@ -19831,20 +19754,13 @@ impl Win32KeyedMutexAcquireReleaseInfoNV { } } } +#[repr(transparent)] pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { inner: Win32KeyedMutexAcquireReleaseInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {} impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { type Target = Win32KeyedMutexAcquireReleaseInfoNV; fn deref(&self) -> &Self::Target { @@ -19925,13 +19841,12 @@ impl DeviceGeneratedCommandsFeaturesNVX { } } } +#[repr(transparent)] pub struct DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { inner: DeviceGeneratedCommandsFeaturesNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGeneratedCommandsFeaturesNVX { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDeviceGeneratedCommandsFeaturesNVX {} impl<'a> ::std::ops::Deref for DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { type Target = DeviceGeneratedCommandsFeaturesNVX; fn deref(&self) -> &Self::Target { @@ -19961,7 +19876,7 @@ impl<'a> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { next: &'a mut T, ) -> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -20003,13 +19918,12 @@ impl DeviceGeneratedCommandsLimitsNVX { } } } +#[repr(transparent)] pub struct DeviceGeneratedCommandsLimitsNVXBuilder<'a> { inner: DeviceGeneratedCommandsLimitsNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGeneratedCommandsLimitsNVX { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDeviceGeneratedCommandsLimitsNVX {} impl<'a> ::std::ops::Deref for DeviceGeneratedCommandsLimitsNVXBuilder<'a> { type Target = DeviceGeneratedCommandsLimitsNVX; fn deref(&self) -> &Self::Target { @@ -20071,7 +19985,7 @@ impl<'a> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { next: &'a mut T, ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -20096,6 +20010,7 @@ impl IndirectCommandsTokenNVX { } } } +#[repr(transparent)] pub struct IndirectCommandsTokenNVXBuilder<'a> { inner: IndirectCommandsTokenNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20147,6 +20062,7 @@ impl IndirectCommandsLayoutTokenNVX { } } } +#[repr(transparent)] pub struct IndirectCommandsLayoutTokenNVXBuilder<'a> { inner: IndirectCommandsLayoutTokenNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20219,13 +20135,12 @@ impl IndirectCommandsLayoutCreateInfoNVX { } } } +#[repr(transparent)] pub struct IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { inner: IndirectCommandsLayoutCreateInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsIndirectCommandsLayoutCreateInfoNVX { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsIndirectCommandsLayoutCreateInfoNVX {} impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { type Target = IndirectCommandsLayoutCreateInfoNVX; fn deref(&self) -> &Self::Target { @@ -20270,7 +20185,7 @@ impl<'a> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { next: &'a mut T, ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -20322,13 +20237,12 @@ impl CmdProcessCommandsInfoNVX { } } } +#[repr(transparent)] pub struct CmdProcessCommandsInfoNVXBuilder<'a> { inner: CmdProcessCommandsInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCmdProcessCommandsInfoNVX { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCmdProcessCommandsInfoNVX {} impl<'a> ::std::ops::Deref for CmdProcessCommandsInfoNVXBuilder<'a> { type Target = CmdProcessCommandsInfoNVX; fn deref(&self) -> &Self::Target { @@ -20415,7 +20329,7 @@ impl<'a> CmdProcessCommandsInfoNVXBuilder<'a> { next: &'a mut T, ) -> CmdProcessCommandsInfoNVXBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -20453,13 +20367,12 @@ impl CmdReserveSpaceForCommandsInfoNVX { } } } +#[repr(transparent)] pub struct CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { inner: CmdReserveSpaceForCommandsInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCmdReserveSpaceForCommandsInfoNVX { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCmdReserveSpaceForCommandsInfoNVX {} impl<'a> ::std::ops::Deref for CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { type Target = CmdReserveSpaceForCommandsInfoNVX; fn deref(&self) -> &Self::Target { @@ -20503,7 +20416,7 @@ impl<'a> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { next: &'a mut T, ) -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -20553,13 +20466,12 @@ impl ObjectTableCreateInfoNVX { } } } +#[repr(transparent)] pub struct ObjectTableCreateInfoNVXBuilder<'a> { inner: ObjectTableCreateInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsObjectTableCreateInfoNVX { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsObjectTableCreateInfoNVX {} impl<'a> ::std::ops::Deref for ObjectTableCreateInfoNVXBuilder<'a> { type Target = ObjectTableCreateInfoNVX; fn deref(&self) -> &Self::Target { @@ -20641,7 +20553,7 @@ impl<'a> ObjectTableCreateInfoNVXBuilder<'a> { next: &'a mut T, ) -> ObjectTableCreateInfoNVXBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -20665,6 +20577,7 @@ impl ObjectTableEntryNVX { } } } +#[repr(transparent)] pub struct ObjectTableEntryNVXBuilder<'a> { inner: ObjectTableEntryNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20708,6 +20621,7 @@ impl ObjectTablePipelineEntryNVX { } } } +#[repr(transparent)] pub struct ObjectTablePipelineEntryNVXBuilder<'a> { inner: ObjectTablePipelineEntryNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20759,6 +20673,7 @@ impl ObjectTableDescriptorSetEntryNVX { } } } +#[repr(transparent)] pub struct ObjectTableDescriptorSetEntryNVXBuilder<'a> { inner: ObjectTableDescriptorSetEntryNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20819,6 +20734,7 @@ impl ObjectTableVertexBufferEntryNVX { } } } +#[repr(transparent)] pub struct ObjectTableVertexBufferEntryNVXBuilder<'a> { inner: ObjectTableVertexBufferEntryNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20870,6 +20786,7 @@ impl ObjectTableIndexBufferEntryNVX { } } } +#[repr(transparent)] pub struct ObjectTableIndexBufferEntryNVXBuilder<'a> { inner: ObjectTableIndexBufferEntryNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20928,6 +20845,7 @@ impl ObjectTablePushConstantEntryNVX { } } } +#[repr(transparent)] pub struct ObjectTablePushConstantEntryNVXBuilder<'a> { inner: ObjectTablePushConstantEntryNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -20997,20 +20915,13 @@ impl PhysicalDeviceFeatures2 { } } } +#[repr(transparent)] pub struct PhysicalDeviceFeatures2Builder<'a> { inner: PhysicalDeviceFeatures2, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {} impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> { type Target = PhysicalDeviceFeatures2; fn deref(&self) -> &Self::Target { @@ -21058,13 +20969,12 @@ impl PhysicalDeviceProperties2 { } } } +#[repr(transparent)] pub struct PhysicalDeviceProperties2Builder<'a> { inner: PhysicalDeviceProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceProperties2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceProperties2 {} impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> { type Target = PhysicalDeviceProperties2; fn deref(&self) -> &Self::Target { @@ -21094,7 +21004,7 @@ impl<'a> PhysicalDeviceProperties2Builder<'a> { next: &'a mut T, ) -> PhysicalDeviceProperties2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21128,13 +21038,12 @@ impl FormatProperties2 { } } } +#[repr(transparent)] pub struct FormatProperties2Builder<'a> { inner: FormatProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFormatProperties2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsFormatProperties2 {} impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> { type Target = FormatProperties2; fn deref(&self) -> &Self::Target { @@ -21164,7 +21073,7 @@ impl<'a> FormatProperties2Builder<'a> { next: &'a mut T, ) -> FormatProperties2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21198,13 +21107,12 @@ impl ImageFormatProperties2 { } } } +#[repr(transparent)] pub struct ImageFormatProperties2Builder<'a> { inner: ImageFormatProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageFormatProperties2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImageFormatProperties2 {} impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> { type Target = ImageFormatProperties2; fn deref(&self) -> &Self::Target { @@ -21234,7 +21142,7 @@ impl<'a> ImageFormatProperties2Builder<'a> { next: &'a mut T, ) -> ImageFormatProperties2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21276,13 +21184,12 @@ impl PhysicalDeviceImageFormatInfo2 { } } } +#[repr(transparent)] pub struct PhysicalDeviceImageFormatInfo2Builder<'a> { inner: PhysicalDeviceImageFormatInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {} impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> { type Target = PhysicalDeviceImageFormatInfo2; fn deref(&self) -> &Self::Target { @@ -21325,7 +21232,7 @@ impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { next: &'a mut T, ) -> PhysicalDeviceImageFormatInfo2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21359,13 +21266,12 @@ impl QueueFamilyProperties2 { } } } +#[repr(transparent)] pub struct QueueFamilyProperties2Builder<'a> { inner: QueueFamilyProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsQueueFamilyProperties2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsQueueFamilyProperties2 {} impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> { type Target = QueueFamilyProperties2; fn deref(&self) -> &Self::Target { @@ -21395,7 +21301,7 @@ impl<'a> QueueFamilyProperties2Builder<'a> { next: &'a mut T, ) -> QueueFamilyProperties2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21429,13 +21335,12 @@ impl PhysicalDeviceMemoryProperties2 { } } } +#[repr(transparent)] pub struct PhysicalDeviceMemoryProperties2Builder<'a> { inner: PhysicalDeviceMemoryProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {} impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> { type Target = PhysicalDeviceMemoryProperties2; fn deref(&self) -> &Self::Target { @@ -21465,7 +21370,7 @@ impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { next: &'a mut T, ) -> PhysicalDeviceMemoryProperties2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21499,13 +21404,12 @@ impl SparseImageFormatProperties2 { } } } +#[repr(transparent)] pub struct SparseImageFormatProperties2Builder<'a> { inner: SparseImageFormatProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSparseImageFormatProperties2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSparseImageFormatProperties2 {} impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> { type Target = SparseImageFormatProperties2; fn deref(&self) -> &Self::Target { @@ -21535,7 +21439,7 @@ impl<'a> SparseImageFormatProperties2Builder<'a> { next: &'a mut T, ) -> SparseImageFormatProperties2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21577,13 +21481,12 @@ impl PhysicalDeviceSparseImageFormatInfo2 { } } } +#[repr(transparent)] pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> { inner: PhysicalDeviceSparseImageFormatInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSparseImageFormatInfo2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceSparseImageFormatInfo2 {} impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { type Target = PhysicalDeviceSparseImageFormatInfo2; fn deref(&self) -> &Self::Target { @@ -21635,7 +21538,7 @@ impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { next: &'a mut T, ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -21669,6 +21572,7 @@ impl PhysicalDevicePushDescriptorPropertiesKHR { } } } +#[repr(transparent)] pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { inner: PhysicalDevicePushDescriptorPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -21676,15 +21580,8 @@ pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {} impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { type Target = PhysicalDevicePushDescriptorPropertiesKHR; fn deref(&self) -> &Self::Target { @@ -21724,6 +21621,7 @@ impl ConformanceVersionKHR { } } } +#[repr(transparent)] pub struct ConformanceVersionKHRBuilder<'a> { inner: ConformanceVersionKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -21806,20 +21704,13 @@ impl PhysicalDeviceDriverPropertiesKHR { } } } +#[repr(transparent)] pub struct PhysicalDeviceDriverPropertiesKHRBuilder<'a> { inner: PhysicalDeviceDriverPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesKHRBuilder<'a> { type Target = PhysicalDeviceDriverPropertiesKHR; fn deref(&self) -> &Self::Target { @@ -21890,20 +21781,13 @@ impl PresentRegionsKHR { } } } +#[repr(transparent)] pub struct PresentRegionsKHRBuilder<'a> { inner: PresentRegionsKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {} impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> { type Target = PresentRegionsKHR; fn deref(&self) -> &Self::Target { @@ -21947,6 +21831,7 @@ impl PresentRegionKHR { } } } +#[repr(transparent)] pub struct PresentRegionKHRBuilder<'a> { inner: PresentRegionKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -21987,6 +21872,7 @@ impl RectLayerKHR { } } } +#[repr(transparent)] pub struct RectLayerKHRBuilder<'a> { inner: RectLayerKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -22045,20 +21931,13 @@ impl PhysicalDeviceVariablePointerFeatures { } } } +#[repr(transparent)] pub struct PhysicalDeviceVariablePointerFeaturesBuilder<'a> { inner: PhysicalDeviceVariablePointerFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointerFeaturesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointerFeatures { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointerFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointerFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointerFeaturesBuilder<'a> { type Target = PhysicalDeviceVariablePointerFeatures; fn deref(&self) -> &Self::Target { @@ -22104,6 +21983,7 @@ impl ExternalMemoryProperties { } } } +#[repr(transparent)] pub struct ExternalMemoryPropertiesBuilder<'a> { inner: ExternalMemoryProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -22169,6 +22049,7 @@ impl PhysicalDeviceExternalImageFormatInfo { } } } +#[repr(transparent)] pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> { inner: PhysicalDeviceExternalImageFormatInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -22176,15 +22057,8 @@ pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> { unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { type Target = PhysicalDeviceExternalImageFormatInfo; fn deref(&self) -> &Self::Target { @@ -22232,20 +22106,13 @@ impl ExternalImageFormatProperties { } } } +#[repr(transparent)] pub struct ExternalImageFormatPropertiesBuilder<'a> { inner: ExternalImageFormatProperties, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {} impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> { type Target = ExternalImageFormatProperties; fn deref(&self) -> &Self::Target { @@ -22297,13 +22164,12 @@ impl PhysicalDeviceExternalBufferInfo { } } } +#[repr(transparent)] pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> { inner: PhysicalDeviceExternalBufferInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo {} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> { type Target = PhysicalDeviceExternalBufferInfo; fn deref(&self) -> &Self::Target { @@ -22344,7 +22210,7 @@ impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { next: &'a mut T, ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -22378,13 +22244,12 @@ impl ExternalBufferProperties { } } } +#[repr(transparent)] pub struct ExternalBufferPropertiesBuilder<'a> { inner: ExternalBufferProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalBufferProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsExternalBufferProperties {} impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> { type Target = ExternalBufferProperties; fn deref(&self) -> &Self::Target { @@ -22414,7 +22279,7 @@ impl<'a> ExternalBufferPropertiesBuilder<'a> { next: &'a mut T, ) -> ExternalBufferPropertiesBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -22456,20 +22321,13 @@ impl PhysicalDeviceIDProperties { } } } +#[repr(transparent)] pub struct PhysicalDeviceIDPropertiesBuilder<'a> { inner: PhysicalDeviceIDProperties, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {} impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> { type Target = PhysicalDeviceIDProperties; fn deref(&self) -> &Self::Target { @@ -22545,20 +22403,13 @@ impl ExternalMemoryImageCreateInfo { } } } +#[repr(transparent)] pub struct ExternalMemoryImageCreateInfoBuilder<'a> { inner: ExternalMemoryImageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {} impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> { type Target = ExternalMemoryImageCreateInfo; fn deref(&self) -> &Self::Target { @@ -22606,20 +22457,13 @@ impl ExternalMemoryBufferCreateInfo { } } } +#[repr(transparent)] pub struct ExternalMemoryBufferCreateInfoBuilder<'a> { inner: ExternalMemoryBufferCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {} impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> { type Target = ExternalMemoryBufferCreateInfo; fn deref(&self) -> &Self::Target { @@ -22667,20 +22511,13 @@ impl ExportMemoryAllocateInfo { } } } +#[repr(transparent)] pub struct ExportMemoryAllocateInfoBuilder<'a> { inner: ExportMemoryAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {} impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> { type Target = ExportMemoryAllocateInfo; fn deref(&self) -> &Self::Target { @@ -22732,20 +22569,13 @@ impl ImportMemoryWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> { inner: ImportMemoryWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> { type Target = ImportMemoryWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -22805,20 +22635,13 @@ impl ExportMemoryWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> { inner: ExportMemoryWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> { type Target = ExportMemoryWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -22874,13 +22697,12 @@ impl MemoryWin32HandlePropertiesKHR { } } } +#[repr(transparent)] pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> { inner: MemoryWin32HandlePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryWin32HandlePropertiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryWin32HandlePropertiesKHR {} impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> { type Target = MemoryWin32HandlePropertiesKHR; fn deref(&self) -> &Self::Target { @@ -22910,7 +22732,7 @@ impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { next: &'a mut T, ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -22946,13 +22768,12 @@ impl MemoryGetWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> { inner: MemoryGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryGetWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> { type Target = MemoryGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -22986,7 +22807,7 @@ impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { next: &'a mut T, ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23022,20 +22843,13 @@ impl ImportMemoryFdInfoKHR { } } } +#[repr(transparent)] pub struct ImportMemoryFdInfoKHRBuilder<'a> { inner: ImportMemoryFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {} impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> { type Target = ImportMemoryFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -23087,13 +22901,12 @@ impl MemoryFdPropertiesKHR { } } } +#[repr(transparent)] pub struct MemoryFdPropertiesKHRBuilder<'a> { inner: MemoryFdPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryFdPropertiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryFdPropertiesKHR {} impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> { type Target = MemoryFdPropertiesKHR; fn deref(&self) -> &Self::Target { @@ -23120,7 +22933,7 @@ impl<'a> MemoryFdPropertiesKHRBuilder<'a> { next: &'a mut T, ) -> MemoryFdPropertiesKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23156,13 +22969,12 @@ impl MemoryGetFdInfoKHR { } } } +#[repr(transparent)] pub struct MemoryGetFdInfoKHRBuilder<'a> { inner: MemoryGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetFdInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryGetFdInfoKHR {} impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> { type Target = MemoryGetFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -23196,7 +23008,7 @@ impl<'a> MemoryGetFdInfoKHRBuilder<'a> { next: &'a mut T, ) -> MemoryGetFdInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23242,20 +23054,13 @@ impl Win32KeyedMutexAcquireReleaseInfoKHR { } } } +#[repr(transparent)] pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { inner: Win32KeyedMutexAcquireReleaseInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {} impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { type Target = Win32KeyedMutexAcquireReleaseInfoKHR; fn deref(&self) -> &Self::Target { @@ -23336,13 +23141,12 @@ impl PhysicalDeviceExternalSemaphoreInfo { } } } +#[repr(transparent)] pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { inner: PhysicalDeviceExternalSemaphoreInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { type Target = PhysicalDeviceExternalSemaphoreInfo; fn deref(&self) -> &Self::Target { @@ -23372,7 +23176,7 @@ impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { next: &'a mut T, ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23410,13 +23214,12 @@ impl ExternalSemaphoreProperties { } } } +#[repr(transparent)] pub struct ExternalSemaphorePropertiesBuilder<'a> { inner: ExternalSemaphoreProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalSemaphoreProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsExternalSemaphoreProperties {} impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> { type Target = ExternalSemaphoreProperties; fn deref(&self) -> &Self::Target { @@ -23460,7 +23263,7 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> { next: &'a mut T, ) -> ExternalSemaphorePropertiesBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23494,20 +23297,13 @@ impl ExportSemaphoreCreateInfo { } } } +#[repr(transparent)] pub struct ExportSemaphoreCreateInfoBuilder<'a> { inner: ExportSemaphoreCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {} impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> { type Target = ExportSemaphoreCreateInfo; fn deref(&self) -> &Self::Target { @@ -23563,13 +23359,12 @@ impl ImportSemaphoreWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { inner: ImportSemaphoreWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportSemaphoreWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImportSemaphoreWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { type Target = ImportSemaphoreWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -23621,7 +23416,7 @@ impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { next: &'a mut T, ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23659,20 +23454,13 @@ impl ExportSemaphoreWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { inner: ExportSemaphoreWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { type Target = ExportSemaphoreWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -23734,20 +23522,13 @@ impl D3D12FenceSubmitInfoKHR { } } } +#[repr(transparent)] pub struct D3D12FenceSubmitInfoKHRBuilder<'a> { inner: D3D12FenceSubmitInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {} impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> { type Target = D3D12FenceSubmitInfoKHR; fn deref(&self) -> &Self::Target { @@ -23806,13 +23587,12 @@ impl SemaphoreGetWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> { inner: SemaphoreGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreGetWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSemaphoreGetWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { type Target = SemaphoreGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -23846,7 +23626,7 @@ impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { next: &'a mut T, ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23886,13 +23666,12 @@ impl ImportSemaphoreFdInfoKHR { } } } +#[repr(transparent)] pub struct ImportSemaphoreFdInfoKHRBuilder<'a> { inner: ImportSemaphoreFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportSemaphoreFdInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImportSemaphoreFdInfoKHR {} impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> { type Target = ImportSemaphoreFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -23934,7 +23713,7 @@ impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { next: &'a mut T, ) -> ImportSemaphoreFdInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -23970,13 +23749,12 @@ impl SemaphoreGetFdInfoKHR { } } } +#[repr(transparent)] pub struct SemaphoreGetFdInfoKHRBuilder<'a> { inner: SemaphoreGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreGetFdInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSemaphoreGetFdInfoKHR {} impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> { type Target = SemaphoreGetFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -24010,7 +23788,7 @@ impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { next: &'a mut T, ) -> SemaphoreGetFdInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -24044,13 +23822,12 @@ impl PhysicalDeviceExternalFenceInfo { } } } +#[repr(transparent)] pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> { inner: PhysicalDeviceExternalFenceInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalFenceInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceExternalFenceInfo {} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> { type Target = PhysicalDeviceExternalFenceInfo; fn deref(&self) -> &Self::Target { @@ -24080,7 +23857,7 @@ impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { next: &'a mut T, ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -24118,13 +23895,12 @@ impl ExternalFenceProperties { } } } +#[repr(transparent)] pub struct ExternalFencePropertiesBuilder<'a> { inner: ExternalFenceProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalFenceProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsExternalFenceProperties {} impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> { type Target = ExternalFenceProperties; fn deref(&self) -> &Self::Target { @@ -24168,7 +23944,7 @@ impl<'a> ExternalFencePropertiesBuilder<'a> { next: &'a mut T, ) -> ExternalFencePropertiesBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -24202,20 +23978,13 @@ impl ExportFenceCreateInfo { } } } +#[repr(transparent)] pub struct ExportFenceCreateInfoBuilder<'a> { inner: ExportFenceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {} impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> { type Target = ExportFenceCreateInfo; fn deref(&self) -> &Self::Target { @@ -24271,13 +24040,12 @@ impl ImportFenceWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> { inner: ImportFenceWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportFenceWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImportFenceWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> { type Target = ImportFenceWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -24323,7 +24091,7 @@ impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { next: &'a mut T, ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -24361,20 +24129,13 @@ impl ExportFenceWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> { inner: ExportFenceWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> { type Target = ExportFenceWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -24432,13 +24193,12 @@ impl FenceGetWin32HandleInfoKHR { } } } +#[repr(transparent)] pub struct FenceGetWin32HandleInfoKHRBuilder<'a> { inner: FenceGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceGetWin32HandleInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsFenceGetWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> { type Target = FenceGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -24472,7 +24232,7 @@ impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { next: &'a mut T, ) -> FenceGetWin32HandleInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -24512,13 +24272,12 @@ impl ImportFenceFdInfoKHR { } } } +#[repr(transparent)] pub struct ImportFenceFdInfoKHRBuilder<'a> { inner: ImportFenceFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportFenceFdInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImportFenceFdInfoKHR {} impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> { type Target = ImportFenceFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -24560,7 +24319,7 @@ impl<'a> ImportFenceFdInfoKHRBuilder<'a> { next: &'a mut T, ) -> ImportFenceFdInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -24596,13 +24355,12 @@ impl FenceGetFdInfoKHR { } } } +#[repr(transparent)] pub struct FenceGetFdInfoKHRBuilder<'a> { inner: FenceGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceGetFdInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsFenceGetFdInfoKHR {} impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> { type Target = FenceGetFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -24636,7 +24394,7 @@ impl<'a> FenceGetFdInfoKHRBuilder<'a> { next: &'a mut T, ) -> FenceGetFdInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -24674,20 +24432,13 @@ impl PhysicalDeviceMultiviewFeatures { } } } +#[repr(transparent)] pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> { inner: PhysicalDeviceMultiviewFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> { type Target = PhysicalDeviceMultiviewFeatures; fn deref(&self) -> &Self::Target { @@ -24748,20 +24499,13 @@ impl PhysicalDeviceMultiviewProperties { } } } +#[repr(transparent)] pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> { inner: PhysicalDeviceMultiviewProperties, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {} impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> { type Target = PhysicalDeviceMultiviewProperties; fn deref(&self) -> &Self::Target { @@ -24826,20 +24570,13 @@ impl RenderPassMultiviewCreateInfo { } } } +#[repr(transparent)] pub struct RenderPassMultiviewCreateInfoBuilder<'a> { inner: RenderPassMultiviewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {} impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> { type Target = RenderPassMultiviewCreateInfo; fn deref(&self) -> &Self::Target { @@ -24921,13 +24658,12 @@ impl SurfaceCapabilities2EXT { } } } +#[repr(transparent)] pub struct SurfaceCapabilities2EXTBuilder<'a> { inner: SurfaceCapabilities2EXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceCapabilities2EXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSurfaceCapabilities2EXT {} impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> { type Target = SurfaceCapabilities2EXT; fn deref(&self) -> &Self::Target { @@ -25021,7 +24757,7 @@ impl<'a> SurfaceCapabilities2EXTBuilder<'a> { next: &'a mut T, ) -> SurfaceCapabilities2EXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -25055,13 +24791,12 @@ impl DisplayPowerInfoEXT { } } } +#[repr(transparent)] pub struct DisplayPowerInfoEXTBuilder<'a> { inner: DisplayPowerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPowerInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayPowerInfoEXT {} impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> { type Target = DisplayPowerInfoEXT; fn deref(&self) -> &Self::Target { @@ -25091,7 +24826,7 @@ impl<'a> DisplayPowerInfoEXTBuilder<'a> { next: &'a mut T, ) -> DisplayPowerInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -25125,13 +24860,12 @@ impl DeviceEventInfoEXT { } } } +#[repr(transparent)] pub struct DeviceEventInfoEXTBuilder<'a> { inner: DeviceEventInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceEventInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDeviceEventInfoEXT {} impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> { type Target = DeviceEventInfoEXT; fn deref(&self) -> &Self::Target { @@ -25161,7 +24895,7 @@ impl<'a> DeviceEventInfoEXTBuilder<'a> { next: &'a mut T, ) -> DeviceEventInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -25195,13 +24929,12 @@ impl DisplayEventInfoEXT { } } } +#[repr(transparent)] pub struct DisplayEventInfoEXTBuilder<'a> { inner: DisplayEventInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayEventInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayEventInfoEXT {} impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> { type Target = DisplayEventInfoEXT; fn deref(&self) -> &Self::Target { @@ -25231,7 +24964,7 @@ impl<'a> DisplayEventInfoEXTBuilder<'a> { next: &'a mut T, ) -> DisplayEventInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -25265,20 +24998,13 @@ impl SwapchainCounterCreateInfoEXT { } } } +#[repr(transparent)] pub struct SwapchainCounterCreateInfoEXTBuilder<'a> { inner: SwapchainCounterCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {} impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> { type Target = SwapchainCounterCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -25330,13 +25056,12 @@ impl PhysicalDeviceGroupProperties { } } } +#[repr(transparent)] pub struct PhysicalDeviceGroupPropertiesBuilder<'a> { inner: PhysicalDeviceGroupProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceGroupProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceGroupProperties {} impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> { type Target = PhysicalDeviceGroupProperties; fn deref(&self) -> &Self::Target { @@ -25380,7 +25105,7 @@ impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { next: &'a mut T, ) -> PhysicalDeviceGroupPropertiesBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -25416,20 +25141,13 @@ impl MemoryAllocateFlagsInfo { } } } +#[repr(transparent)] pub struct MemoryAllocateFlagsInfoBuilder<'a> { inner: MemoryAllocateFlagsInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {} impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> { type Target = MemoryAllocateFlagsInfo; fn deref(&self) -> &Self::Target { @@ -25482,13 +25200,12 @@ impl BindBufferMemoryInfo { } } } +#[repr(transparent)] pub struct BindBufferMemoryInfoBuilder<'a> { inner: BindBufferMemoryInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindBufferMemoryInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBindBufferMemoryInfo {} impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> { type Target = BindBufferMemoryInfo; fn deref(&self) -> &Self::Target { @@ -25523,7 +25240,7 @@ impl<'a> BindBufferMemoryInfoBuilder<'a> { next: &'a mut T, ) -> BindBufferMemoryInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -25559,20 +25276,13 @@ impl BindBufferMemoryDeviceGroupInfo { } } } +#[repr(transparent)] pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> { inner: BindBufferMemoryDeviceGroupInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {} impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> { type Target = BindBufferMemoryDeviceGroupInfo; fn deref(&self) -> &Self::Target { @@ -25625,13 +25335,12 @@ impl BindImageMemoryInfo { } } } +#[repr(transparent)] pub struct BindImageMemoryInfoBuilder<'a> { inner: BindImageMemoryInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindImageMemoryInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBindImageMemoryInfo {} impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> { type Target = BindImageMemoryInfo; fn deref(&self) -> &Self::Target { @@ -25666,7 +25375,7 @@ impl<'a> BindImageMemoryInfoBuilder<'a> { next: &'a mut T, ) -> BindImageMemoryInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -25706,20 +25415,13 @@ impl BindImageMemoryDeviceGroupInfo { } } } +#[repr(transparent)] pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> { inner: BindImageMemoryDeviceGroupInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {} impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> { type Target = BindImageMemoryDeviceGroupInfo; fn deref(&self) -> &Self::Target { @@ -25780,20 +25482,13 @@ impl DeviceGroupRenderPassBeginInfo { } } } +#[repr(transparent)] pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> { inner: DeviceGroupRenderPassBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {} impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> { type Target = DeviceGroupRenderPassBeginInfo; fn deref(&self) -> &Self::Target { @@ -25846,20 +25541,13 @@ impl DeviceGroupCommandBufferBeginInfo { } } } +#[repr(transparent)] pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> { inner: DeviceGroupCommandBufferBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {} impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> { type Target = DeviceGroupCommandBufferBeginInfo; fn deref(&self) -> &Self::Target { @@ -25914,20 +25602,13 @@ impl DeviceGroupSubmitInfo { } } } +#[repr(transparent)] pub struct DeviceGroupSubmitInfoBuilder<'a> { inner: DeviceGroupSubmitInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {} impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> { type Target = DeviceGroupSubmitInfo; fn deref(&self) -> &Self::Target { @@ -25994,20 +25675,13 @@ impl DeviceGroupBindSparseInfo { } } } +#[repr(transparent)] pub struct DeviceGroupBindSparseInfoBuilder<'a> { inner: DeviceGroupBindSparseInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {} impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> { type Target = DeviceGroupBindSparseInfo; fn deref(&self) -> &Self::Target { @@ -26064,13 +25738,12 @@ impl DeviceGroupPresentCapabilitiesKHR { } } } +#[repr(transparent)] pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> { inner: DeviceGroupPresentCapabilitiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupPresentCapabilitiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDeviceGroupPresentCapabilitiesKHR {} impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { type Target = DeviceGroupPresentCapabilitiesKHR; fn deref(&self) -> &Self::Target { @@ -26107,7 +25780,7 @@ impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { next: &'a mut T, ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -26141,20 +25814,13 @@ impl ImageSwapchainCreateInfoKHR { } } } +#[repr(transparent)] pub struct ImageSwapchainCreateInfoKHRBuilder<'a> { inner: ImageSwapchainCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {} impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> { type Target = ImageSwapchainCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -26201,20 +25867,13 @@ impl BindImageMemorySwapchainInfoKHR { } } } +#[repr(transparent)] pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> { inner: BindImageMemorySwapchainInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {} impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> { type Target = BindImageMemorySwapchainInfoKHR; fn deref(&self) -> &Self::Target { @@ -26274,13 +25933,12 @@ impl AcquireNextImageInfoKHR { } } } +#[repr(transparent)] pub struct AcquireNextImageInfoKHRBuilder<'a> { inner: AcquireNextImageInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAcquireNextImageInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAcquireNextImageInfoKHR {} impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> { type Target = AcquireNextImageInfoKHR; fn deref(&self) -> &Self::Target { @@ -26323,7 +25981,7 @@ impl<'a> AcquireNextImageInfoKHRBuilder<'a> { next: &'a mut T, ) -> AcquireNextImageInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -26361,20 +26019,13 @@ impl DeviceGroupPresentInfoKHR { } } } +#[repr(transparent)] pub struct DeviceGroupPresentInfoKHRBuilder<'a> { inner: DeviceGroupPresentInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {} impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> { type Target = DeviceGroupPresentInfoKHR; fn deref(&self) -> &Self::Target { @@ -26429,20 +26080,13 @@ impl DeviceGroupDeviceCreateInfo { } } } +#[repr(transparent)] pub struct DeviceGroupDeviceCreateInfoBuilder<'a> { inner: DeviceGroupDeviceCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {} impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> { type Target = DeviceGroupDeviceCreateInfo; fn deref(&self) -> &Self::Target { @@ -26491,20 +26135,13 @@ impl DeviceGroupSwapchainCreateInfoKHR { } } } +#[repr(transparent)] pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { inner: DeviceGroupSwapchainCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {} impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { type Target = DeviceGroupSwapchainCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -26546,6 +26183,7 @@ impl DescriptorUpdateTemplateEntry { } } } +#[repr(transparent)] pub struct DescriptorUpdateTemplateEntryBuilder<'a> { inner: DescriptorUpdateTemplateEntry, marker: ::std::marker::PhantomData<&'a ()>, @@ -26637,13 +26275,12 @@ impl DescriptorUpdateTemplateCreateInfo { } } } +#[repr(transparent)] pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> { inner: DescriptorUpdateTemplateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorUpdateTemplateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDescriptorUpdateTemplateCreateInfo {} impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> { type Target = DescriptorUpdateTemplateCreateInfo; fn deref(&self) -> &Self::Target { @@ -26713,7 +26350,7 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { next: &'a mut T, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -26737,6 +26374,7 @@ impl XYColorEXT { } } } +#[repr(transparent)] pub struct XYColorEXTBuilder<'a> { inner: XYColorEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -26803,13 +26441,12 @@ impl HdrMetadataEXT { } } } +#[repr(transparent)] pub struct HdrMetadataEXTBuilder<'a> { inner: HdrMetadataEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsHdrMetadataEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsHdrMetadataEXT {} impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> { type Target = HdrMetadataEXT; fn deref(&self) -> &Self::Target { @@ -26879,7 +26516,7 @@ impl<'a> HdrMetadataEXTBuilder<'a> { next: &'a mut T, ) -> HdrMetadataEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -26902,6 +26539,7 @@ impl RefreshCycleDurationGOOGLE { } } } +#[repr(transparent)] pub struct RefreshCycleDurationGOOGLEBuilder<'a> { inner: RefreshCycleDurationGOOGLE, marker: ::std::marker::PhantomData<&'a ()>, @@ -26946,6 +26584,7 @@ impl PastPresentationTimingGOOGLE { } } } +#[repr(transparent)] pub struct PastPresentationTimingGOOGLEBuilder<'a> { inner: PastPresentationTimingGOOGLE, marker: ::std::marker::PhantomData<&'a ()>, @@ -27024,20 +26663,13 @@ impl PresentTimesInfoGOOGLE { } } } +#[repr(transparent)] pub struct PresentTimesInfoGOOGLEBuilder<'a> { inner: PresentTimesInfoGOOGLE, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {} impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> { type Target = PresentTimesInfoGOOGLE; fn deref(&self) -> &Self::Target { @@ -27073,6 +26705,7 @@ impl PresentTimeGOOGLE { } } } +#[repr(transparent)] pub struct PresentTimeGOOGLEBuilder<'a> { inner: PresentTimeGOOGLE, marker: ::std::marker::PhantomData<&'a ()>, @@ -27130,13 +26763,12 @@ impl IOSSurfaceCreateInfoMVK { } } } +#[repr(transparent)] pub struct IOSSurfaceCreateInfoMVKBuilder<'a> { inner: IOSSurfaceCreateInfoMVK, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsIOSSurfaceCreateInfoMVK { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsIOSSurfaceCreateInfoMVK {} impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> { type Target = IOSSurfaceCreateInfoMVK; fn deref(&self) -> &Self::Target { @@ -27167,7 +26799,7 @@ impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { next: &'a mut T, ) -> IOSSurfaceCreateInfoMVKBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -27203,13 +26835,12 @@ impl MacOSSurfaceCreateInfoMVK { } } } +#[repr(transparent)] pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { inner: MacOSSurfaceCreateInfoMVK, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMacOSSurfaceCreateInfoMVK { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMacOSSurfaceCreateInfoMVK {} impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { type Target = MacOSSurfaceCreateInfoMVK; fn deref(&self) -> &Self::Target { @@ -27243,7 +26874,7 @@ impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { next: &'a mut T, ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -27267,6 +26898,7 @@ impl ViewportWScalingNV { } } } +#[repr(transparent)] pub struct ViewportWScalingNVBuilder<'a> { inner: ViewportWScalingNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -27323,6 +26955,7 @@ impl PipelineViewportWScalingStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { inner: PipelineViewportWScalingStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -27330,15 +26963,8 @@ pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {} impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportWScalingStateCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -27386,6 +27012,7 @@ impl ViewportSwizzleNV { } } } +#[repr(transparent)] pub struct ViewportSwizzleNVBuilder<'a> { inner: ViewportSwizzleNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -27450,6 +27077,7 @@ impl PipelineViewportSwizzleStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { inner: PipelineViewportSwizzleStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -27457,15 +27085,8 @@ pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {} impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportSwizzleStateCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -27521,6 +27142,7 @@ impl PhysicalDeviceDiscardRectanglePropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { inner: PhysicalDeviceDiscardRectanglePropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -27528,15 +27150,8 @@ pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { type Target = PhysicalDeviceDiscardRectanglePropertiesEXT; fn deref(&self) -> &Self::Target { @@ -27590,6 +27205,7 @@ impl PipelineDiscardRectangleStateCreateInfoEXT { } } } +#[repr(transparent)] pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { inner: PipelineDiscardRectangleStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -27597,15 +27213,8 @@ pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {} impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { type Target = PipelineDiscardRectangleStateCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -27668,6 +27277,7 @@ impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { } } } +#[repr(transparent)] pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, marker: ::std::marker::PhantomData<&'a ()>, @@ -27675,16 +27285,10 @@ pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; @@ -27724,6 +27328,7 @@ impl InputAttachmentAspectReference { } } } +#[repr(transparent)] pub struct InputAttachmentAspectReferenceBuilder<'a> { inner: InputAttachmentAspectReference, marker: ::std::marker::PhantomData<&'a ()>, @@ -27788,20 +27393,13 @@ impl RenderPassInputAttachmentAspectCreateInfo { } } } +#[repr(transparent)] pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { inner: RenderPassInputAttachmentAspectCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {} impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { type Target = RenderPassInputAttachmentAspectCreateInfo; fn deref(&self) -> &Self::Target { @@ -27850,13 +27448,12 @@ impl PhysicalDeviceSurfaceInfo2KHR { } } } +#[repr(transparent)] pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { inner: PhysicalDeviceSurfaceInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { type Target = PhysicalDeviceSurfaceInfo2KHR; fn deref(&self) -> &Self::Target { @@ -27883,7 +27480,7 @@ impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { next: &'a mut T, ) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -27917,13 +27514,12 @@ impl SurfaceCapabilities2KHR { } } } +#[repr(transparent)] pub struct SurfaceCapabilities2KHRBuilder<'a> { inner: SurfaceCapabilities2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceCapabilities2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSurfaceCapabilities2KHR {} impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> { type Target = SurfaceCapabilities2KHR; fn deref(&self) -> &Self::Target { @@ -27953,7 +27549,7 @@ impl<'a> SurfaceCapabilities2KHRBuilder<'a> { next: &'a mut T, ) -> SurfaceCapabilities2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -27987,13 +27583,12 @@ impl SurfaceFormat2KHR { } } } +#[repr(transparent)] pub struct SurfaceFormat2KHRBuilder<'a> { inner: SurfaceFormat2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceFormat2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSurfaceFormat2KHR {} impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { type Target = SurfaceFormat2KHR; fn deref(&self) -> &Self::Target { @@ -28023,7 +27618,7 @@ impl<'a> SurfaceFormat2KHRBuilder<'a> { next: &'a mut T, ) -> SurfaceFormat2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28057,13 +27652,12 @@ impl DisplayProperties2KHR { } } } +#[repr(transparent)] pub struct DisplayProperties2KHRBuilder<'a> { inner: DisplayProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayProperties2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayProperties2KHR {} impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> { type Target = DisplayProperties2KHR; fn deref(&self) -> &Self::Target { @@ -28093,7 +27687,7 @@ impl<'a> DisplayProperties2KHRBuilder<'a> { next: &'a mut T, ) -> DisplayProperties2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28127,13 +27721,12 @@ impl DisplayPlaneProperties2KHR { } } } +#[repr(transparent)] pub struct DisplayPlaneProperties2KHRBuilder<'a> { inner: DisplayPlaneProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneProperties2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayPlaneProperties2KHR {} impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> { type Target = DisplayPlaneProperties2KHR; fn deref(&self) -> &Self::Target { @@ -28163,7 +27756,7 @@ impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { next: &'a mut T, ) -> DisplayPlaneProperties2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28197,13 +27790,12 @@ impl DisplayModeProperties2KHR { } } } +#[repr(transparent)] pub struct DisplayModeProperties2KHRBuilder<'a> { inner: DisplayModeProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayModeProperties2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayModeProperties2KHR {} impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> { type Target = DisplayModeProperties2KHR; fn deref(&self) -> &Self::Target { @@ -28233,7 +27825,7 @@ impl<'a> DisplayModeProperties2KHRBuilder<'a> { next: &'a mut T, ) -> DisplayModeProperties2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28269,13 +27861,12 @@ impl DisplayPlaneInfo2KHR { } } } +#[repr(transparent)] pub struct DisplayPlaneInfo2KHRBuilder<'a> { inner: DisplayPlaneInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneInfo2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayPlaneInfo2KHR {} impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> { type Target = DisplayPlaneInfo2KHR; fn deref(&self) -> &Self::Target { @@ -28306,7 +27897,7 @@ impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { next: &'a mut T, ) -> DisplayPlaneInfo2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28340,13 +27931,12 @@ impl DisplayPlaneCapabilities2KHR { } } } +#[repr(transparent)] pub struct DisplayPlaneCapabilities2KHRBuilder<'a> { inner: DisplayPlaneCapabilities2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneCapabilities2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDisplayPlaneCapabilities2KHR {} impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> { type Target = DisplayPlaneCapabilities2KHR; fn deref(&self) -> &Self::Target { @@ -28376,7 +27966,7 @@ impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { next: &'a mut T, ) -> DisplayPlaneCapabilities2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28410,20 +28000,13 @@ impl SharedPresentSurfaceCapabilitiesKHR { } } } +#[repr(transparent)] pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { inner: SharedPresentSurfaceCapabilitiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {} impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { type Target = SharedPresentSurfaceCapabilitiesKHR; fn deref(&self) -> &Self::Target { @@ -28477,20 +28060,13 @@ impl PhysicalDevice16BitStorageFeatures { } } } +#[repr(transparent)] pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> { inner: PhysicalDevice16BitStorageFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {} impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> { type Target = PhysicalDevice16BitStorageFeatures; fn deref(&self) -> &Self::Target { @@ -28566,20 +28142,13 @@ impl PhysicalDeviceSubgroupProperties { } } } +#[repr(transparent)] pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> { inner: PhysicalDeviceSubgroupProperties, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {} impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> { type Target = PhysicalDeviceSubgroupProperties; fn deref(&self) -> &Self::Target { @@ -28648,13 +28217,12 @@ impl BufferMemoryRequirementsInfo2 { } } } +#[repr(transparent)] pub struct BufferMemoryRequirementsInfo2Builder<'a> { inner: BufferMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferMemoryRequirementsInfo2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBufferMemoryRequirementsInfo2 {} impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> { type Target = BufferMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { @@ -28681,7 +28249,7 @@ impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { next: &'a mut T, ) -> BufferMemoryRequirementsInfo2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28715,13 +28283,12 @@ impl ImageMemoryRequirementsInfo2 { } } } +#[repr(transparent)] pub struct ImageMemoryRequirementsInfo2Builder<'a> { inner: ImageMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageMemoryRequirementsInfo2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {} impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> { type Target = ImageMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { @@ -28748,7 +28315,7 @@ impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { next: &'a mut T, ) -> ImageMemoryRequirementsInfo2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28782,13 +28349,12 @@ impl ImageSparseMemoryRequirementsInfo2 { } } } +#[repr(transparent)] pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> { inner: ImageSparseMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageSparseMemoryRequirementsInfo2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImageSparseMemoryRequirementsInfo2 {} impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> { type Target = ImageSparseMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { @@ -28815,7 +28381,7 @@ impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { next: &'a mut T, ) -> ImageSparseMemoryRequirementsInfo2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28849,13 +28415,12 @@ impl MemoryRequirements2 { } } } +#[repr(transparent)] pub struct MemoryRequirements2Builder<'a> { inner: MemoryRequirements2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryRequirements2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryRequirements2 {} impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> { type Target = MemoryRequirements2; fn deref(&self) -> &Self::Target { @@ -28885,7 +28450,7 @@ impl<'a> MemoryRequirements2Builder<'a> { next: &'a mut T, ) -> MemoryRequirements2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28919,13 +28484,12 @@ impl SparseImageMemoryRequirements2 { } } } +#[repr(transparent)] pub struct SparseImageMemoryRequirements2Builder<'a> { inner: SparseImageMemoryRequirements2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSparseImageMemoryRequirements2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSparseImageMemoryRequirements2 {} impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> { type Target = SparseImageMemoryRequirements2; fn deref(&self) -> &Self::Target { @@ -28955,7 +28519,7 @@ impl<'a> SparseImageMemoryRequirements2Builder<'a> { next: &'a mut T, ) -> SparseImageMemoryRequirements2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -28989,20 +28553,13 @@ impl PhysicalDevicePointClippingProperties { } } } +#[repr(transparent)] pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> { inner: PhysicalDevicePointClippingProperties, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {} impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> { type Target = PhysicalDevicePointClippingProperties; fn deref(&self) -> &Self::Target { @@ -29052,20 +28609,13 @@ impl MemoryDedicatedRequirements { } } } +#[repr(transparent)] pub struct MemoryDedicatedRequirementsBuilder<'a> { inner: MemoryDedicatedRequirements, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {} impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> { type Target = MemoryDedicatedRequirements; fn deref(&self) -> &Self::Target { @@ -29122,20 +28672,13 @@ impl MemoryDedicatedAllocateInfo { } } } +#[repr(transparent)] pub struct MemoryDedicatedAllocateInfoBuilder<'a> { inner: MemoryDedicatedAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {} impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> { type Target = MemoryDedicatedAllocateInfo; fn deref(&self) -> &Self::Target { @@ -29184,20 +28727,13 @@ impl ImageViewUsageCreateInfo { } } } +#[repr(transparent)] pub struct ImageViewUsageCreateInfoBuilder<'a> { inner: ImageViewUsageCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {} impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> { type Target = ImageViewUsageCreateInfo; fn deref(&self) -> &Self::Target { @@ -29242,6 +28778,7 @@ impl PipelineTessellationDomainOriginStateCreateInfo { } } } +#[repr(transparent)] pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { inner: PipelineTessellationDomainOriginStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, @@ -29249,16 +28786,10 @@ pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { unsafe impl ExtendsPipelineTessellationStateCreateInfo for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineTessellationStateCreateInfo for PipelineTessellationDomainOriginStateCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { type Target = PipelineTessellationDomainOriginStateCreateInfo; @@ -29307,20 +28838,13 @@ impl SamplerYcbcrConversionInfo { } } } +#[repr(transparent)] pub struct SamplerYcbcrConversionInfoBuilder<'a> { inner: SamplerYcbcrConversionInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {} impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> { type Target = SamplerYcbcrConversionInfo; fn deref(&self) -> &Self::Target { @@ -29382,13 +28906,12 @@ impl SamplerYcbcrConversionCreateInfo { } } } +#[repr(transparent)] pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> { inner: SamplerYcbcrConversionCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {} impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> { type Target = SamplerYcbcrConversionCreateInfo; fn deref(&self) -> &Self::Target { @@ -29464,7 +28987,7 @@ impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { next: &'a mut T, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -29498,20 +29021,13 @@ impl BindImagePlaneMemoryInfo { } } } +#[repr(transparent)] pub struct BindImagePlaneMemoryInfoBuilder<'a> { inner: BindImagePlaneMemoryInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {} impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> { type Target = BindImagePlaneMemoryInfo; fn deref(&self) -> &Self::Target { @@ -29559,20 +29075,13 @@ impl ImagePlaneMemoryRequirementsInfo { } } } +#[repr(transparent)] pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> { inner: ImagePlaneMemoryRequirementsInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {} impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> { type Target = ImagePlaneMemoryRequirementsInfo; fn deref(&self) -> &Self::Target { @@ -29620,20 +29129,13 @@ impl PhysicalDeviceSamplerYcbcrConversionFeatures { } } } +#[repr(transparent)] pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { inner: PhysicalDeviceSamplerYcbcrConversionFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { type Target = PhysicalDeviceSamplerYcbcrConversionFeatures; fn deref(&self) -> &Self::Target { @@ -29681,6 +29183,7 @@ impl SamplerYcbcrConversionImageFormatProperties { } } } +#[repr(transparent)] pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { inner: SamplerYcbcrConversionImageFormatProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -29688,15 +29191,8 @@ pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {} impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { type Target = SamplerYcbcrConversionImageFormatProperties; fn deref(&self) -> &Self::Target { @@ -29745,20 +29241,13 @@ impl TextureLODGatherFormatPropertiesAMD { } } } +#[repr(transparent)] pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> { inner: TextureLODGatherFormatPropertiesAMD, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {} impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> { type Target = TextureLODGatherFormatPropertiesAMD; fn deref(&self) -> &Self::Target { @@ -29811,13 +29300,12 @@ impl ConditionalRenderingBeginInfoEXT { } } } +#[repr(transparent)] pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> { inner: ConditionalRenderingBeginInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsConditionalRenderingBeginInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsConditionalRenderingBeginInfoEXT {} impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> { type Target = ConditionalRenderingBeginInfoEXT; fn deref(&self) -> &Self::Target { @@ -29855,7 +29343,7 @@ impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { next: &'a mut T, ) -> ConditionalRenderingBeginInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -29889,20 +29377,13 @@ impl ProtectedSubmitInfo { } } } +#[repr(transparent)] pub struct ProtectedSubmitInfoBuilder<'a> { inner: ProtectedSubmitInfo, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {} impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> { type Target = ProtectedSubmitInfo; fn deref(&self) -> &Self::Target { @@ -29947,20 +29428,13 @@ impl PhysicalDeviceProtectedMemoryFeatures { } } } +#[repr(transparent)] pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { inner: PhysicalDeviceProtectedMemoryFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { type Target = PhysicalDeviceProtectedMemoryFeatures; fn deref(&self) -> &Self::Target { @@ -30008,6 +29482,7 @@ impl PhysicalDeviceProtectedMemoryProperties { } } } +#[repr(transparent)] pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { inner: PhysicalDeviceProtectedMemoryProperties, marker: ::std::marker::PhantomData<&'a ()>, @@ -30015,15 +29490,8 @@ pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {} impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { type Target = PhysicalDeviceProtectedMemoryProperties; fn deref(&self) -> &Self::Target { @@ -30075,13 +29543,12 @@ impl DeviceQueueInfo2 { } } } +#[repr(transparent)] pub struct DeviceQueueInfo2Builder<'a> { inner: DeviceQueueInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceQueueInfo2 { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDeviceQueueInfo2 {} impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> { type Target = DeviceQueueInfo2; fn deref(&self) -> &Self::Target { @@ -30116,7 +29583,7 @@ impl<'a> DeviceQueueInfo2Builder<'a> { next: &'a mut T, ) -> DeviceQueueInfo2Builder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -30154,6 +29621,7 @@ impl PipelineCoverageToColorStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { inner: PipelineCoverageToColorStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -30161,15 +29629,8 @@ pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {} impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { type Target = PipelineCoverageToColorStateCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -30233,6 +29694,7 @@ impl PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { inner: PhysicalDeviceSamplerFilterMinmaxPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -30240,15 +29702,8 @@ pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceSamplerFilterMinmaxPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -30295,6 +29750,7 @@ impl SampleLocationEXT { } } } +#[repr(transparent)] pub struct SampleLocationEXTBuilder<'a> { inner: SampleLocationEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -30353,20 +29809,13 @@ impl SampleLocationsInfoEXT { } } } +#[repr(transparent)] pub struct SampleLocationsInfoEXTBuilder<'a> { inner: SampleLocationsInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {} impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> { type Target = SampleLocationsInfoEXT; fn deref(&self) -> &Self::Target { @@ -30419,6 +29868,7 @@ impl AttachmentSampleLocationsEXT { } } } +#[repr(transparent)] pub struct AttachmentSampleLocationsEXTBuilder<'a> { inner: AttachmentSampleLocationsEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -30467,6 +29917,7 @@ impl SubpassSampleLocationsEXT { } } } +#[repr(transparent)] pub struct SubpassSampleLocationsEXTBuilder<'a> { inner: SubpassSampleLocationsEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -30528,20 +29979,13 @@ impl RenderPassSampleLocationsBeginInfoEXT { } } } +#[repr(transparent)] pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { inner: RenderPassSampleLocationsBeginInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {} impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { type Target = RenderPassSampleLocationsBeginInfoEXT; fn deref(&self) -> &Self::Target { @@ -30602,6 +30046,7 @@ impl PipelineSampleLocationsStateCreateInfoEXT { } } } +#[repr(transparent)] pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { inner: PipelineSampleLocationsStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -30609,16 +30054,10 @@ pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineSampleLocationsStateCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { type Target = PipelineSampleLocationsStateCreateInfoEXT; @@ -30682,6 +30121,7 @@ impl PhysicalDeviceSampleLocationsPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { inner: PhysicalDeviceSampleLocationsPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -30689,15 +30129,8 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceSampleLocationsPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -30773,13 +30206,12 @@ impl MultisamplePropertiesEXT { } } } +#[repr(transparent)] pub struct MultisamplePropertiesEXTBuilder<'a> { inner: MultisamplePropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMultisamplePropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMultisamplePropertiesEXT {} impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> { type Target = MultisamplePropertiesEXT; fn deref(&self) -> &Self::Target { @@ -30809,7 +30241,7 @@ impl<'a> MultisamplePropertiesEXTBuilder<'a> { next: &'a mut T, ) -> MultisamplePropertiesEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -30843,20 +30275,13 @@ impl SamplerReductionModeCreateInfoEXT { } } } +#[repr(transparent)] pub struct SamplerReductionModeCreateInfoEXTBuilder<'a> { inner: SamplerReductionModeCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoEXT {} impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoEXTBuilder<'a> { type Target = SamplerReductionModeCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -30904,20 +30329,13 @@ impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -30975,6 +30393,7 @@ impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -30982,15 +30401,8 @@ pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -31079,6 +30491,7 @@ impl PipelineColorBlendAdvancedStateCreateInfoEXT { } } } +#[repr(transparent)] pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { inner: PipelineColorBlendAdvancedStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -31086,16 +30499,10 @@ pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorBlendAdvancedStateCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { type Target = PipelineColorBlendAdvancedStateCreateInfoEXT; @@ -31160,20 +30567,13 @@ impl PhysicalDeviceInlineUniformBlockFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { inner: PhysicalDeviceInlineUniformBlockFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceInlineUniformBlockFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -31238,6 +30638,7 @@ impl PhysicalDeviceInlineUniformBlockPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { inner: PhysicalDeviceInlineUniformBlockPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -31245,15 +30646,8 @@ pub struct PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceInlineUniformBlockPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -31337,20 +30731,13 @@ impl WriteDescriptorSetInlineUniformBlockEXT { } } } +#[repr(transparent)] pub struct WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> { inner: WriteDescriptorSetInlineUniformBlockEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXTBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXT {} impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> { type Target = WriteDescriptorSetInlineUniformBlockEXT; fn deref(&self) -> &Self::Target { @@ -31396,6 +30783,7 @@ impl DescriptorPoolInlineUniformBlockCreateInfoEXT { } } } +#[repr(transparent)] pub struct DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { inner: DescriptorPoolInlineUniformBlockCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -31403,15 +30791,8 @@ pub struct DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXT {} impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> { type Target = DescriptorPoolInlineUniformBlockCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -31467,6 +30848,7 @@ impl PipelineCoverageModulationStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { inner: PipelineCoverageModulationStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -31474,16 +30856,10 @@ pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageModulationStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageModulationStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { type Target = PipelineCoverageModulationStateCreateInfoNV; @@ -31556,20 +30932,13 @@ impl ImageFormatListCreateInfoKHR { } } } +#[repr(transparent)] pub struct ImageFormatListCreateInfoKHRBuilder<'a> { inner: ImageFormatListCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHR {} impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoKHRBuilder<'a> { type Target = ImageFormatListCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -31622,13 +30991,12 @@ impl ValidationCacheCreateInfoEXT { } } } +#[repr(transparent)] pub struct ValidationCacheCreateInfoEXTBuilder<'a> { inner: ValidationCacheCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsValidationCacheCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsValidationCacheCreateInfoEXT {} impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> { type Target = ValidationCacheCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -31666,7 +31034,7 @@ impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { next: &'a mut T, ) -> ValidationCacheCreateInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -31700,20 +31068,13 @@ impl ShaderModuleValidationCacheCreateInfoEXT { } } } +#[repr(transparent)] pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { inner: ShaderModuleValidationCacheCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {} impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { type Target = ShaderModuleValidationCacheCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -31763,20 +31124,13 @@ impl PhysicalDeviceMaintenance3Properties { } } } +#[repr(transparent)] pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> { inner: PhysicalDeviceMaintenance3Properties, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {} impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { type Target = PhysicalDeviceMaintenance3Properties; fn deref(&self) -> &Self::Target { @@ -31831,13 +31185,12 @@ impl DescriptorSetLayoutSupport { } } } +#[repr(transparent)] pub struct DescriptorSetLayoutSupportBuilder<'a> { inner: DescriptorSetLayoutSupport, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorSetLayoutSupport { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDescriptorSetLayoutSupport {} impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> { type Target = DescriptorSetLayoutSupport; fn deref(&self) -> &Self::Target { @@ -31864,7 +31217,7 @@ impl<'a> DescriptorSetLayoutSupportBuilder<'a> { next: &'a mut T, ) -> DescriptorSetLayoutSupportBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -31898,20 +31251,13 @@ impl PhysicalDeviceShaderDrawParameterFeatures { } } } +#[repr(transparent)] pub struct PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { inner: PhysicalDeviceShaderDrawParameterFeatures, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParameterFeaturesBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParameterFeatures { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParameterFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParameterFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParameterFeaturesBuilder<'a> { type Target = PhysicalDeviceShaderDrawParameterFeatures; fn deref(&self) -> &Self::Target { @@ -31961,20 +31307,13 @@ impl PhysicalDeviceFloat16Int8FeaturesKHR { } } } +#[repr(transparent)] pub struct PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> { inner: PhysicalDeviceFloat16Int8FeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFloat16Int8FeaturesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFloat16Int8FeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceFloat16Int8FeaturesKHRBuilder<'a> { type Target = PhysicalDeviceFloat16Int8FeaturesKHR; fn deref(&self) -> &Self::Target { @@ -32061,6 +31400,7 @@ impl PhysicalDeviceFloatControlsPropertiesKHR { } } } +#[repr(transparent)] pub struct PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { inner: PhysicalDeviceFloatControlsPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -32068,15 +31408,8 @@ pub struct PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesKHRBuilder<'a> { type Target = PhysicalDeviceFloatControlsPropertiesKHR; fn deref(&self) -> &Self::Target { @@ -32245,13 +31578,12 @@ impl NativeBufferANDROID { } } } +#[repr(transparent)] pub struct NativeBufferANDROIDBuilder<'a> { inner: NativeBufferANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsNativeBufferANDROID { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsNativeBufferANDROID {} impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> { type Target = NativeBufferANDROID; fn deref(&self) -> &Self::Target { @@ -32290,7 +31622,7 @@ impl<'a> NativeBufferANDROIDBuilder<'a> { next: &'a mut T, ) -> NativeBufferANDROIDBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -32317,6 +31649,7 @@ impl ShaderResourceUsageAMD { } } } +#[repr(transparent)] pub struct ShaderResourceUsageAMDBuilder<'a> { inner: ShaderResourceUsageAMD, marker: ::std::marker::PhantomData<&'a ()>, @@ -32398,6 +31731,7 @@ impl ShaderStatisticsInfoAMD { } } } +#[repr(transparent)] pub struct ShaderStatisticsInfoAMDBuilder<'a> { inner: ShaderStatisticsInfoAMD, marker: ::std::marker::PhantomData<&'a ()>, @@ -32491,20 +31825,13 @@ impl DeviceQueueGlobalPriorityCreateInfoEXT { } } } +#[repr(transparent)] pub struct DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { inner: DeviceQueueGlobalPriorityCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXT {} impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> { type Target = DeviceQueueGlobalPriorityCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -32556,13 +31883,12 @@ impl DebugUtilsObjectNameInfoEXT { } } } +#[repr(transparent)] pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> { inner: DebugUtilsObjectNameInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsObjectNameInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDebugUtilsObjectNameInfoEXT {} impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> { type Target = DebugUtilsObjectNameInfoEXT; fn deref(&self) -> &Self::Target { @@ -32603,7 +31929,7 @@ impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { next: &'a mut T, ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -32645,13 +31971,12 @@ impl DebugUtilsObjectTagInfoEXT { } } } +#[repr(transparent)] pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> { inner: DebugUtilsObjectTagInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsObjectTagInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDebugUtilsObjectTagInfoEXT {} impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> { type Target = DebugUtilsObjectTagInfoEXT; fn deref(&self) -> &Self::Target { @@ -32691,7 +32016,7 @@ impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { next: &'a mut T, ) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -32727,13 +32052,12 @@ impl DebugUtilsLabelEXT { } } } +#[repr(transparent)] pub struct DebugUtilsLabelEXTBuilder<'a> { inner: DebugUtilsLabelEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsLabelEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDebugUtilsLabelEXT {} impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> { type Target = DebugUtilsLabelEXT; fn deref(&self) -> &Self::Target { @@ -32764,7 +32088,7 @@ impl<'a> DebugUtilsLabelEXTBuilder<'a> { next: &'a mut T, ) -> DebugUtilsLabelEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -32822,20 +32146,13 @@ impl DebugUtilsMessengerCreateInfoEXT { } } } +#[repr(transparent)] pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> { inner: DebugUtilsMessengerCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {} impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { type Target = DebugUtilsMessengerCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -32929,13 +32246,12 @@ impl DebugUtilsMessengerCallbackDataEXT { } } } +#[repr(transparent)] pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> { inner: DebugUtilsMessengerCallbackDataEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {} impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { type Target = DebugUtilsMessengerCallbackDataEXT; fn deref(&self) -> &Self::Target { @@ -33010,7 +32326,7 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { next: &'a mut T, ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -33046,20 +32362,13 @@ impl ImportMemoryHostPointerInfoEXT { } } } +#[repr(transparent)] pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> { inner: ImportMemoryHostPointerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {} impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> { type Target = ImportMemoryHostPointerInfoEXT; fn deref(&self) -> &Self::Target { @@ -33114,13 +32423,12 @@ impl MemoryHostPointerPropertiesEXT { } } } +#[repr(transparent)] pub struct MemoryHostPointerPropertiesEXTBuilder<'a> { inner: MemoryHostPointerPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryHostPointerPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryHostPointerPropertiesEXT {} impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> { type Target = MemoryHostPointerPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -33150,7 +32458,7 @@ impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { next: &'a mut T, ) -> MemoryHostPointerPropertiesEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -33184,6 +32492,7 @@ impl PhysicalDeviceExternalMemoryHostPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { inner: PhysicalDeviceExternalMemoryHostPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -33191,15 +32500,8 @@ pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -33263,6 +32565,7 @@ impl PhysicalDeviceConservativeRasterizationPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { inner: PhysicalDeviceConservativeRasterizationPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -33270,16 +32573,10 @@ pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceConservativeRasterizationPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT; @@ -33389,13 +32686,12 @@ impl CalibratedTimestampInfoEXT { } } } +#[repr(transparent)] pub struct CalibratedTimestampInfoEXTBuilder<'a> { inner: CalibratedTimestampInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCalibratedTimestampInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCalibratedTimestampInfoEXT {} impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> { type Target = CalibratedTimestampInfoEXT; fn deref(&self) -> &Self::Target { @@ -33425,7 +32721,7 @@ impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { next: &'a mut T, ) -> CalibratedTimestampInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -33485,20 +32781,13 @@ impl PhysicalDeviceShaderCorePropertiesAMD { } } } +#[repr(transparent)] pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { inner: PhysicalDeviceShaderCorePropertiesAMD, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { type Target = PhysicalDeviceShaderCorePropertiesAMD; fn deref(&self) -> &Self::Target { @@ -33641,6 +32930,7 @@ impl PipelineRasterizationConservativeStateCreateInfoEXT { } } } +#[repr(transparent)] pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { inner: PipelineRasterizationConservativeStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -33648,16 +32938,10 @@ pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationConservativeStateCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { type Target = PipelineRasterizationConservativeStateCreateInfoEXT; @@ -33758,20 +33042,13 @@ impl PhysicalDeviceDescriptorIndexingFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { inner: PhysicalDeviceDescriptorIndexingFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceDescriptorIndexingFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -34025,6 +33302,7 @@ impl PhysicalDeviceDescriptorIndexingPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { inner: PhysicalDeviceDescriptorIndexingPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -34032,15 +33310,8 @@ pub struct PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceDescriptorIndexingPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -34284,6 +33555,7 @@ impl DescriptorSetLayoutBindingFlagsCreateInfoEXT { } } } +#[repr(transparent)] pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { inner: DescriptorSetLayoutBindingFlagsCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -34291,15 +33563,8 @@ pub struct DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfoEXT {} impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoEXTBuilder<'a> { type Target = DescriptorSetLayoutBindingFlagsCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -34350,6 +33615,7 @@ impl DescriptorSetVariableDescriptorCountAllocateInfoEXT { } } } +#[repr(transparent)] pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { inner: DescriptorSetVariableDescriptorCountAllocateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -34357,16 +33623,10 @@ pub struct DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoEXTBuilder<'a> { type Target = DescriptorSetVariableDescriptorCountAllocateInfoEXT; @@ -34416,6 +33676,7 @@ impl DescriptorSetVariableDescriptorCountLayoutSupportEXT { } } } +#[repr(transparent)] pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { inner: DescriptorSetVariableDescriptorCountLayoutSupportEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -34423,16 +33684,10 @@ pub struct DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { unsafe impl ExtendsDescriptorSetLayoutSupport for DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsDescriptorSetLayoutSupport for DescriptorSetVariableDescriptorCountLayoutSupportEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportEXTBuilder<'a> { type Target = DescriptorSetVariableDescriptorCountLayoutSupportEXT; @@ -34497,13 +33752,12 @@ impl AttachmentDescription2KHR { } } } +#[repr(transparent)] pub struct AttachmentDescription2KHRBuilder<'a> { inner: AttachmentDescription2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAttachmentDescription2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAttachmentDescription2KHR {} impl<'a> ::std::ops::Deref for AttachmentDescription2KHRBuilder<'a> { type Target = AttachmentDescription2KHR; fn deref(&self) -> &Self::Target { @@ -34577,7 +33831,7 @@ impl<'a> AttachmentDescription2KHRBuilder<'a> { next: &'a mut T, ) -> AttachmentDescription2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -34615,13 +33869,12 @@ impl AttachmentReference2KHR { } } } +#[repr(transparent)] pub struct AttachmentReference2KHRBuilder<'a> { inner: AttachmentReference2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAttachmentReference2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAttachmentReference2KHR {} impl<'a> ::std::ops::Deref for AttachmentReference2KHRBuilder<'a> { type Target = AttachmentReference2KHR; fn deref(&self) -> &Self::Target { @@ -34659,7 +33912,7 @@ impl<'a> AttachmentReference2KHRBuilder<'a> { next: &'a mut T, ) -> AttachmentReference2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -34713,13 +33966,12 @@ impl SubpassDescription2KHR { } } } +#[repr(transparent)] pub struct SubpassDescription2KHRBuilder<'a> { inner: SubpassDescription2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassDescription2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSubpassDescription2KHR {} impl<'a> ::std::ops::Deref for SubpassDescription2KHRBuilder<'a> { type Target = SubpassDescription2KHR; fn deref(&self) -> &Self::Target { @@ -34796,7 +34048,7 @@ impl<'a> SubpassDescription2KHRBuilder<'a> { next: &'a mut T, ) -> SubpassDescription2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -34844,13 +34096,12 @@ impl SubpassDependency2KHR { } } } +#[repr(transparent)] pub struct SubpassDependency2KHRBuilder<'a> { inner: SubpassDependency2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassDependency2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSubpassDependency2KHR {} impl<'a> ::std::ops::Deref for SubpassDependency2KHRBuilder<'a> { type Target = SubpassDependency2KHR; fn deref(&self) -> &Self::Target { @@ -34920,7 +34171,7 @@ impl<'a> SubpassDependency2KHRBuilder<'a> { next: &'a mut T, ) -> SubpassDependency2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -34970,13 +34221,12 @@ impl RenderPassCreateInfo2KHR { } } } +#[repr(transparent)] pub struct RenderPassCreateInfo2KHRBuilder<'a> { inner: RenderPassCreateInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRenderPassCreateInfo2KHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsRenderPassCreateInfo2KHR {} impl<'a> ::std::ops::Deref for RenderPassCreateInfo2KHRBuilder<'a> { type Target = RenderPassCreateInfo2KHR; fn deref(&self) -> &Self::Target { @@ -35035,7 +34285,7 @@ impl<'a> RenderPassCreateInfo2KHRBuilder<'a> { next: &'a mut T, ) -> RenderPassCreateInfo2KHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -35069,13 +34319,12 @@ impl SubpassBeginInfoKHR { } } } +#[repr(transparent)] pub struct SubpassBeginInfoKHRBuilder<'a> { inner: SubpassBeginInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassBeginInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSubpassBeginInfoKHR {} impl<'a> ::std::ops::Deref for SubpassBeginInfoKHRBuilder<'a> { type Target = SubpassBeginInfoKHR; fn deref(&self) -> &Self::Target { @@ -35102,7 +34351,7 @@ impl<'a> SubpassBeginInfoKHRBuilder<'a> { next: &'a mut T, ) -> SubpassBeginInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -35134,13 +34383,12 @@ impl SubpassEndInfoKHR { } } } +#[repr(transparent)] pub struct SubpassEndInfoKHRBuilder<'a> { inner: SubpassEndInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassEndInfoKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsSubpassEndInfoKHR {} impl<'a> ::std::ops::Deref for SubpassEndInfoKHRBuilder<'a> { type Target = SubpassEndInfoKHR; fn deref(&self) -> &Self::Target { @@ -35163,7 +34411,7 @@ impl<'a> SubpassEndInfoKHRBuilder<'a> { next: &'a mut T, ) -> SubpassEndInfoKHRBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -35187,6 +34435,7 @@ impl VertexInputBindingDivisorDescriptionEXT { } } } +#[repr(transparent)] pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> { inner: VertexInputBindingDivisorDescriptionEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -35241,6 +34490,7 @@ impl PipelineVertexInputDivisorStateCreateInfoEXT { } } } +#[repr(transparent)] pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { inner: PipelineVertexInputDivisorStateCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -35248,16 +34498,10 @@ pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { unsafe impl ExtendsPipelineVertexInputStateCreateInfo for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineVertexInputStateCreateInfo for PipelineVertexInputDivisorStateCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { type Target = PipelineVertexInputDivisorStateCreateInfoEXT; @@ -35307,6 +34551,7 @@ impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -35314,15 +34559,8 @@ pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -35376,20 +34614,13 @@ impl PhysicalDevicePCIBusInfoPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { inner: PhysicalDevicePCIBusInfoPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { type Target = PhysicalDevicePCIBusInfoPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -35455,20 +34686,13 @@ impl ImportAndroidHardwareBufferInfoANDROID { } } } +#[repr(transparent)] pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { inner: ImportAndroidHardwareBufferInfoANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {} impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { type Target = ImportAndroidHardwareBufferInfoANDROID; fn deref(&self) -> &Self::Target { @@ -35516,20 +34740,13 @@ impl AndroidHardwareBufferUsageANDROID { } } } +#[repr(transparent)] pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> { inner: AndroidHardwareBufferUsageANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {} impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> { type Target = AndroidHardwareBufferUsageANDROID; fn deref(&self) -> &Self::Target { @@ -35579,13 +34796,12 @@ impl AndroidHardwareBufferPropertiesANDROID { } } } +#[repr(transparent)] pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { inner: AndroidHardwareBufferPropertiesANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {} impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { type Target = AndroidHardwareBufferPropertiesANDROID; fn deref(&self) -> &Self::Target { @@ -35622,7 +34838,7 @@ impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { next: &'a mut T, ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -35656,13 +34872,12 @@ impl MemoryGetAndroidHardwareBufferInfoANDROID { } } } +#[repr(transparent)] pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { inner: MemoryGetAndroidHardwareBufferInfoANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetAndroidHardwareBufferInfoANDROID { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsMemoryGetAndroidHardwareBufferInfoANDROID {} impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { type Target = MemoryGetAndroidHardwareBufferInfoANDROID; fn deref(&self) -> &Self::Target { @@ -35692,7 +34907,7 @@ impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { next: &'a mut T, ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -35740,6 +34955,7 @@ impl AndroidHardwareBufferFormatPropertiesANDROID { } } } +#[repr(transparent)] pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { inner: AndroidHardwareBufferFormatPropertiesANDROID, marker: ::std::marker::PhantomData<&'a ()>, @@ -35747,16 +34963,10 @@ pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID for AndroidHardwareBufferFormatPropertiesANDROID { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { type Target = AndroidHardwareBufferFormatPropertiesANDROID; @@ -35854,6 +35064,7 @@ impl CommandBufferInheritanceConditionalRenderingInfoEXT { } } } +#[repr(transparent)] pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { inner: CommandBufferInheritanceConditionalRenderingInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -35861,16 +35072,10 @@ pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceConditionalRenderingInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { type Target = CommandBufferInheritanceConditionalRenderingInfoEXT; @@ -35919,20 +35124,13 @@ impl ExternalFormatANDROID { } } } +#[repr(transparent)] pub struct ExternalFormatANDROIDBuilder<'a> { inner: ExternalFormatANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {} impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> { type Target = ExternalFormatANDROID; fn deref(&self) -> &Self::Target { @@ -35981,20 +35179,13 @@ impl PhysicalDevice8BitStorageFeaturesKHR { } } } +#[repr(transparent)] pub struct PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> { inner: PhysicalDevice8BitStorageFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesKHRBuilder<'a> { type Target = PhysicalDevice8BitStorageFeaturesKHR; fn deref(&self) -> &Self::Target { @@ -36059,20 +35250,13 @@ impl PhysicalDeviceConditionalRenderingFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { inner: PhysicalDeviceConditionalRenderingFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceConditionalRenderingFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -36129,20 +35313,13 @@ impl PhysicalDeviceVulkanMemoryModelFeaturesKHR { } } } +#[repr(transparent)] pub struct PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> { inner: PhysicalDeviceVulkanMemoryModelFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesKHRBuilder<'a> { type Target = PhysicalDeviceVulkanMemoryModelFeaturesKHR; fn deref(&self) -> &Self::Target { @@ -36199,20 +35376,13 @@ impl PhysicalDeviceShaderAtomicInt64FeaturesKHR { } } } +#[repr(transparent)] pub struct PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> { inner: PhysicalDeviceShaderAtomicInt64FeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesKHRBuilder<'a> { type Target = PhysicalDeviceShaderAtomicInt64FeaturesKHR; fn deref(&self) -> &Self::Target { @@ -36269,20 +35439,13 @@ impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -36339,20 +35502,13 @@ impl QueueFamilyCheckpointPropertiesNV { } } } +#[repr(transparent)] pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> { inner: QueueFamilyCheckpointPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {} impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> { type Target = QueueFamilyCheckpointPropertiesNV; fn deref(&self) -> &Self::Target { @@ -36402,13 +35558,12 @@ impl CheckpointDataNV { } } } +#[repr(transparent)] pub struct CheckpointDataNVBuilder<'a> { inner: CheckpointDataNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCheckpointDataNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsCheckpointDataNV {} impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> { type Target = CheckpointDataNV; fn deref(&self) -> &Self::Target { @@ -36442,7 +35597,7 @@ impl<'a> CheckpointDataNVBuilder<'a> { next: &'a mut T, ) -> CheckpointDataNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -36482,6 +35637,7 @@ impl PhysicalDeviceDepthStencilResolvePropertiesKHR { } } } +#[repr(transparent)] pub struct PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { inner: PhysicalDeviceDepthStencilResolvePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, @@ -36489,15 +35645,8 @@ pub struct PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { type Target = PhysicalDeviceDepthStencilResolvePropertiesKHR; fn deref(&self) -> &Self::Target { @@ -36570,20 +35719,13 @@ impl SubpassDescriptionDepthStencilResolveKHR { } } } +#[repr(transparent)] pub struct SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { inner: SubpassDescriptionDepthStencilResolveKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHRBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHR { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHRBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHR {} impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { type Target = SubpassDescriptionDepthStencilResolveKHR; fn deref(&self) -> &Self::Target { @@ -36645,20 +35787,13 @@ impl ImageViewASTCDecodeModeEXT { } } } +#[repr(transparent)] pub struct ImageViewASTCDecodeModeEXTBuilder<'a> { inner: ImageViewASTCDecodeModeEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {} impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> { type Target = ImageViewASTCDecodeModeEXT; fn deref(&self) -> &Self::Target { @@ -36703,20 +35838,13 @@ impl PhysicalDeviceASTCDecodeFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { inner: PhysicalDeviceASTCDecodeFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceASTCDecodeFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -36766,20 +35894,13 @@ impl PhysicalDeviceTransformFeedbackFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { inner: PhysicalDeviceTransformFeedbackFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceTransformFeedbackFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -36852,6 +35973,7 @@ impl PhysicalDeviceTransformFeedbackPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { inner: PhysicalDeviceTransformFeedbackPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -36859,15 +35981,8 @@ pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceTransformFeedbackPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -36985,6 +36100,7 @@ impl PipelineRasterizationStateStreamCreateInfoEXT { } } } +#[repr(transparent)] pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { inner: PipelineRasterizationStateStreamCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -36992,16 +36108,10 @@ pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationStateStreamCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { type Target = PipelineRasterizationStateStreamCreateInfoEXT; @@ -37057,6 +36167,7 @@ impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37064,15 +36175,8 @@ pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; fn deref(&self) -> &Self::Target { @@ -37120,6 +36224,7 @@ impl PipelineRepresentativeFragmentTestStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { inner: PipelineRepresentativeFragmentTestStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37127,16 +36232,10 @@ pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRepresentativeFragmentTestStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV; @@ -37185,20 +36284,13 @@ impl PhysicalDeviceExclusiveScissorFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { inner: PhysicalDeviceExclusiveScissorFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { type Target = PhysicalDeviceExclusiveScissorFeaturesNV; fn deref(&self) -> &Self::Target { @@ -37248,6 +36340,7 @@ impl PipelineViewportExclusiveScissorStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { inner: PipelineViewportExclusiveScissorStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37255,16 +36348,10 @@ pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportExclusiveScissorStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportExclusiveScissorStateCreateInfoNV; @@ -37314,20 +36401,13 @@ impl PhysicalDeviceCornerSampledImageFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { inner: PhysicalDeviceCornerSampledImageFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { type Target = PhysicalDeviceCornerSampledImageFeaturesNV; fn deref(&self) -> &Self::Target { @@ -37377,6 +36457,7 @@ impl PhysicalDeviceComputeShaderDerivativesFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37384,15 +36465,8 @@ pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV; fn deref(&self) -> &Self::Target { @@ -37447,6 +36521,7 @@ impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37454,15 +36529,8 @@ pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV; fn deref(&self) -> &Self::Target { @@ -37510,20 +36578,13 @@ impl PhysicalDeviceShaderImageFootprintFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { inner: PhysicalDeviceShaderImageFootprintFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { type Target = PhysicalDeviceShaderImageFootprintFeaturesNV; fn deref(&self) -> &Self::Target { @@ -37569,6 +36630,7 @@ impl ShadingRatePaletteNV { } } } +#[repr(transparent)] pub struct ShadingRatePaletteNVBuilder<'a> { inner: ShadingRatePaletteNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37625,6 +36687,7 @@ impl PipelineViewportShadingRateImageStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { inner: PipelineViewportShadingRateImageStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37632,16 +36695,10 @@ pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportShadingRateImageStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportShadingRateImageStateCreateInfoNV; @@ -37700,20 +36757,13 @@ impl PhysicalDeviceShadingRateImageFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { inner: PhysicalDeviceShadingRateImageFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { type Target = PhysicalDeviceShadingRateImageFeaturesNV; fn deref(&self) -> &Self::Target { @@ -37772,6 +36822,7 @@ impl PhysicalDeviceShadingRateImagePropertiesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { inner: PhysicalDeviceShadingRateImagePropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37779,15 +36830,8 @@ pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { type Target = PhysicalDeviceShadingRateImagePropertiesNV; fn deref(&self) -> &Self::Target { @@ -37840,6 +36884,7 @@ impl CoarseSampleLocationNV { } } } +#[repr(transparent)] pub struct CoarseSampleLocationNVBuilder<'a> { inner: CoarseSampleLocationNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37898,6 +36943,7 @@ impl CoarseSampleOrderCustomNV { } } } +#[repr(transparent)] pub struct CoarseSampleOrderCustomNVBuilder<'a> { inner: CoarseSampleOrderCustomNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37965,6 +37011,7 @@ impl PipelineViewportCoarseSampleOrderStateCreateInfoNV { } } } +#[repr(transparent)] pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -37972,16 +37019,10 @@ pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } } unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportCoarseSampleOrderStateCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV; @@ -38040,20 +37081,13 @@ impl PhysicalDeviceMeshShaderFeaturesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { inner: PhysicalDeviceMeshShaderFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { type Target = PhysicalDeviceMeshShaderFeaturesNV; fn deref(&self) -> &Self::Target { @@ -38132,20 +37166,13 @@ impl PhysicalDeviceMeshShaderPropertiesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { inner: PhysicalDeviceMeshShaderPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { type Target = PhysicalDeviceMeshShaderPropertiesNV; fn deref(&self) -> &Self::Target { @@ -38267,6 +37294,7 @@ impl DrawMeshTasksIndirectCommandNV { } } } +#[repr(transparent)] pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> { inner: DrawMeshTasksIndirectCommandNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -38327,13 +37355,12 @@ impl RayTracingShaderGroupCreateInfoNV { } } } +#[repr(transparent)] pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> { inner: RayTracingShaderGroupCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoNV {} impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> { type Target = RayTracingShaderGroupCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -38391,7 +37418,7 @@ impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { next: &'a mut T, ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -38441,13 +37468,12 @@ impl RayTracingPipelineCreateInfoNV { } } } +#[repr(transparent)] pub struct RayTracingPipelineCreateInfoNVBuilder<'a> { inner: RayTracingPipelineCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {} impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> { type Target = RayTracingPipelineCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -38518,7 +37544,7 @@ impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { next: &'a mut T, ) -> RayTracingPipelineCreateInfoNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -38572,13 +37598,12 @@ impl GeometryTrianglesNV { } } } +#[repr(transparent)] pub struct GeometryTrianglesNVBuilder<'a> { inner: GeometryTrianglesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryTrianglesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsGeometryTrianglesNV {} impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> { type Target = GeometryTrianglesNV; fn deref(&self) -> &Self::Target { @@ -38648,7 +37673,7 @@ impl<'a> GeometryTrianglesNVBuilder<'a> { next: &'a mut T, ) -> GeometryTrianglesNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -38688,13 +37713,12 @@ impl GeometryAABBNV { } } } +#[repr(transparent)] pub struct GeometryAABBNVBuilder<'a> { inner: GeometryAABBNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryAABBNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsGeometryAABBNV {} impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> { type Target = GeometryAABBNV; fn deref(&self) -> &Self::Target { @@ -38733,7 +37757,7 @@ impl<'a> GeometryAABBNVBuilder<'a> { next: &'a mut T, ) -> GeometryAABBNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -38757,6 +37781,7 @@ impl GeometryDataNV { } } } +#[repr(transparent)] pub struct GeometryDataNVBuilder<'a> { inner: GeometryDataNV, marker: ::std::marker::PhantomData<&'a ()>, @@ -38813,13 +37838,12 @@ impl GeometryNV { } } } +#[repr(transparent)] pub struct GeometryNVBuilder<'a> { inner: GeometryNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsGeometryNV {} impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> { type Target = GeometryNV; fn deref(&self) -> &Self::Target { @@ -38851,7 +37875,7 @@ impl<'a> GeometryNVBuilder<'a> { #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> GeometryNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -38893,13 +37917,12 @@ impl AccelerationStructureInfoNV { } } } +#[repr(transparent)] pub struct AccelerationStructureInfoNVBuilder<'a> { inner: AccelerationStructureInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAccelerationStructureInfoNV {} impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> { type Target = AccelerationStructureInfoNV; fn deref(&self) -> &Self::Target { @@ -38945,7 +37968,7 @@ impl<'a> AccelerationStructureInfoNVBuilder<'a> { next: &'a mut T, ) -> AccelerationStructureInfoNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -38981,13 +38004,12 @@ impl AccelerationStructureCreateInfoNV { } } } +#[repr(transparent)] pub struct AccelerationStructureCreateInfoNVBuilder<'a> { inner: AccelerationStructureCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureCreateInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {} impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> { type Target = AccelerationStructureCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -39024,7 +38046,7 @@ impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { next: &'a mut T, ) -> AccelerationStructureCreateInfoNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -39066,13 +38088,12 @@ impl BindAccelerationStructureMemoryInfoNV { } } } +#[repr(transparent)] pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> { inner: BindAccelerationStructureMemoryInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoNV {} impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> { type Target = BindAccelerationStructureMemoryInfoNV; fn deref(&self) -> &Self::Target { @@ -39124,7 +38145,7 @@ impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { next: &'a mut T, ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -39160,20 +38181,13 @@ impl WriteDescriptorSetAccelerationStructureNV { } } } +#[repr(transparent)] pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> { inner: WriteDescriptorSetAccelerationStructureNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {} impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { type Target = WriteDescriptorSetAccelerationStructureNV; fn deref(&self) -> &Self::Target { @@ -39224,13 +38238,12 @@ impl AccelerationStructureMemoryRequirementsInfoNV { } } } +#[repr(transparent)] pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { inner: AccelerationStructureMemoryRequirementsInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoNV {} impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { type Target = AccelerationStructureMemoryRequirementsInfoNV; fn deref(&self) -> &Self::Target { @@ -39267,7 +38280,7 @@ impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { next: &'a mut T, ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -39315,20 +38328,13 @@ impl PhysicalDeviceRayTracingPropertiesNV { } } } +#[repr(transparent)] pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { inner: PhysicalDeviceRayTracingPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { type Target = PhysicalDeviceRayTracingPropertiesNV; fn deref(&self) -> &Self::Target { @@ -39428,20 +38434,13 @@ impl DrmFormatModifierPropertiesListEXT { } } } +#[repr(transparent)] pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> { inner: DrmFormatModifierPropertiesListEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {} impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> { type Target = DrmFormatModifierPropertiesListEXT; fn deref(&self) -> &Self::Target { @@ -39481,6 +38480,7 @@ impl DrmFormatModifierPropertiesEXT { } } } +#[repr(transparent)] pub struct DrmFormatModifierPropertiesEXTBuilder<'a> { inner: DrmFormatModifierPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -39552,6 +38552,7 @@ impl PhysicalDeviceImageDrmFormatModifierInfoEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { inner: PhysicalDeviceImageDrmFormatModifierInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -39559,15 +38560,8 @@ pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT; fn deref(&self) -> &Self::Target { @@ -39632,20 +38626,13 @@ impl ImageDrmFormatModifierListCreateInfoEXT { } } } +#[repr(transparent)] pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { inner: ImageDrmFormatModifierListCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {} impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { type Target = ImageDrmFormatModifierListCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -39698,20 +38685,13 @@ impl ImageDrmFormatModifierExplicitCreateInfoEXT { } } } +#[repr(transparent)] pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { inner: ImageDrmFormatModifierExplicitCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {} impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { type Target = ImageDrmFormatModifierExplicitCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -39767,13 +38747,12 @@ impl ImageDrmFormatModifierPropertiesEXT { } } } +#[repr(transparent)] pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> { inner: ImageDrmFormatModifierPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageDrmFormatModifierPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsImageDrmFormatModifierPropertiesEXT {} impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { type Target = ImageDrmFormatModifierPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -39803,7 +38782,7 @@ impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { next: &'a mut T, ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -39837,20 +38816,13 @@ impl ImageStencilUsageCreateInfoEXT { } } } +#[repr(transparent)] pub struct ImageStencilUsageCreateInfoEXTBuilder<'a> { inner: ImageStencilUsageCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXT {} impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoEXTBuilder<'a> { type Target = ImageStencilUsageCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -39898,20 +38870,13 @@ impl DeviceMemoryOverallocationCreateInfoAMD { } } } +#[repr(transparent)] pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { inner: DeviceMemoryOverallocationCreateInfoAMD, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {} impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { type Target = DeviceMemoryOverallocationCreateInfoAMD; fn deref(&self) -> &Self::Target { @@ -39963,20 +38928,13 @@ impl PhysicalDeviceFragmentDensityMapFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -40043,6 +39001,7 @@ impl PhysicalDeviceFragmentDensityMapPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -40050,15 +39009,8 @@ pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -40120,20 +39072,13 @@ impl RenderPassFragmentDensityMapCreateInfoEXT { } } } +#[repr(transparent)] pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { inner: RenderPassFragmentDensityMapCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { type Target = RenderPassFragmentDensityMapCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -40181,20 +39126,13 @@ impl PhysicalDeviceScalarBlockLayoutFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceScalarBlockLayoutFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -40244,6 +39182,7 @@ impl PhysicalDeviceMemoryBudgetPropertiesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { inner: PhysicalDeviceMemoryBudgetPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, @@ -40251,15 +39190,8 @@ pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } } +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -40314,20 +39246,13 @@ impl PhysicalDeviceMemoryPriorityFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { inner: PhysicalDeviceMemoryPriorityFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -40375,20 +39300,13 @@ impl MemoryPriorityAllocateInfoEXT { } } } +#[repr(transparent)] pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { inner: MemoryPriorityAllocateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { type Target = MemoryPriorityAllocateInfoEXT; fn deref(&self) -> &Self::Target { @@ -40437,20 +39355,13 @@ impl PhysicalDeviceBufferAddressFeaturesEXT { } } } +#[repr(transparent)] pub struct PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { inner: PhysicalDeviceBufferAddressFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { type Target = PhysicalDeviceBufferAddressFeaturesEXT; fn deref(&self) -> &Self::Target { @@ -40513,13 +39424,12 @@ impl BufferDeviceAddressInfoEXT { } } } +#[repr(transparent)] pub struct BufferDeviceAddressInfoEXTBuilder<'a> { inner: BufferDeviceAddressInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferDeviceAddressInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; -} +pub unsafe trait ExtendsBufferDeviceAddressInfoEXT {} impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoEXTBuilder<'a> { type Target = BufferDeviceAddressInfoEXT; fn deref(&self) -> &Self::Target { @@ -40546,7 +39456,7 @@ impl<'a> BufferDeviceAddressInfoEXTBuilder<'a> { next: &'a mut T, ) -> BufferDeviceAddressInfoEXTBuilder<'a> { unsafe { - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -40580,20 +39490,13 @@ impl BufferDeviceAddressCreateInfoEXT { } } } +#[repr(transparent)] pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { inner: BufferDeviceAddressCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(&mut self.inner) - } -} -unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure { - ::std::mem::transmute(self) - } -} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { type Target = BufferDeviceAddressCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -58095,14 +56998,293 @@ fn display_flags( } Ok(()) } -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), _ => None, }; if let Some(x) = name { @@ -58112,13 +57294,177 @@ impl fmt::Display for PhysicalDeviceType { } } } -impl fmt::Display for CoverageModulationModeNV { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), + (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), + (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), + ( + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), + (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, + "SHADER_DEVICE_ADDRESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -58143,12 +57489,24 @@ impl fmt::Display for SubpassDescriptionFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OBJECT => Some("OBJECT"), - Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), - Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), _ => None, }; if let Some(x) = name { @@ -58158,6 +57516,420 @@ impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { } } } +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CopyAccelerationStructureModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationFeatureEnableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, + "LOW_MEMORY", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DriverIdKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccelerationStructureTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58174,6 +57946,25 @@ impl fmt::Display for SparseImageFormatFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ValidationFeatureDisableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58193,13 +57984,28 @@ impl fmt::Display for CommandBufferUsageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } _ => None, }; if let Some(x) = name { @@ -58209,41 +58015,6 @@ impl fmt::Display for SamplerAddressMode { } } } -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), - (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), - (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), - (ShaderStageFlags::MISS_NV.0, "MISS_NV"), - (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), - (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), - (ShaderStageFlags::TASK_NV.0, "TASK_NV"), - (ShaderStageFlags::MESH_NV.0, "MESH_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for BlendOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58307,16 +58078,23 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for ValidationFeatureDisableEXT { +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - Self::THREAD_SAFETY => Some("THREAD_SAFETY"), - Self::API_PARAMETERS => Some("API_PARAMETERS"), - Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), - Self::CORE_CHECKS => Some("CORE_CHECKS"), - Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), _ => None, }; if let Some(x) = name { @@ -58326,39 +58104,22 @@ impl fmt::Display for ValidationFeatureDisableEXT { } } } -impl fmt::Display for QueueFlags { +impl fmt::Display for FormatFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), - (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for LogicOp { +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), + Self::EXECUTABLE => Some("EXECUTABLE"), _ => None, }; if let Some(x) = name { @@ -58368,39 +58129,11 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for ResolveModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ResolveModeFlagsKHR::NONE.0, "NONE"), - (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), - (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), - (ResolveModeFlagsKHR::MIN.0, "MIN"), - (ResolveModeFlagsKHR::MAX.0, "MAX"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageTiling { +impl fmt::Display for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), _ => None, }; if let Some(x) = name { @@ -58410,53 +58143,13 @@ impl fmt::Display for ImageTiling { } } } -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), - ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryOverallocationBehaviorAMD { +impl fmt::Display for CoarseSampleOrderTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::DEFAULT => Some("DEFAULT"), - Self::ALLOWED => Some("ALLOWED"), - Self::DISALLOWED => Some("DISALLOWED"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), _ => None, }; if let Some(x) = name { @@ -58466,37 +58159,73 @@ impl fmt::Display for MemoryOverallocationBehaviorAMD { } } } -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrModelConversion { +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), + (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), + (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), + (ShaderStageFlags::MISS_NV.0, "MISS_NV"), + (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), + (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), + (ShaderStageFlags::TASK_NV.0, "TASK_NV"), + (ShaderStageFlags::MESH_NV.0, "MESH_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), _ => None, }; if let Some(x) = name { @@ -58506,36 +58235,11 @@ impl fmt::Display for SamplerYcbcrModelConversion { } } } -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceEventTypeEXT { +impl fmt::Display for CommandBufferLevel { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), _ => None, }; if let Some(x) = name { @@ -58545,6 +58249,27 @@ impl fmt::Display for DeviceEventTypeEXT { } } } +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for QueryPipelineStatisticFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58596,12 +58321,6 @@ impl fmt::Display for QueryPipelineStatisticFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ConditionalRenderingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for BlendOverlapEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58617,176 +58336,6 @@ impl fmt::Display for BlendOverlapEXT { } } } -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoarseSampleOrderTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58806,262 +58355,6 @@ impl fmt::Display for ExternalMemoryFeatureFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - ( - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, - "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", - ), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"), - (AccessFlags::RESERVED_31_KHR.0, "RESERVED_31_KHR"), - (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"), - (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"), - ( - AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_WRITE_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", - ), - ( - AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, - "CONDITIONAL_RENDERING_READ_EXT", - ), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ( - AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, - "SHADING_RATE_IMAGE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, - "ACCELERATION_STRUCTURE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, - "ACCELERATION_STRUCTURE_WRITE_NV", - ), - ( - AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, - "FRAGMENT_DENSITY_MAP_READ_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), - (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), - (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for SystemAllocationScope { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59079,6 +58372,87 @@ impl fmt::Display for SystemAllocationScope { } } } +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59102,173 +58476,6 @@ impl fmt::Display for PrimitiveTopology { } } } -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BuildAccelerationStructureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, - "ALLOW_UPDATE", - ), - ( - BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, - "ALLOW_COMPACTION", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, - "PREFER_FAST_TRACE", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, - "PREFER_FAST_BUILD", - ), - ( - BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, - "LOW_MEMORY", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), - (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_BUFFER_EXT", - ), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", - ), - ( - BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), - ( - BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, - "SHADER_DEVICE_ADDRESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59903,12 +59110,10 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for RayTracingShaderGroupTypeNV { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), _ => None, }; if let Some(x) = name { @@ -59918,51 +59123,42 @@ impl fmt::Display for RayTracingShaderGroupTypeNV { } } } -impl fmt::Display for RenderPassCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { +impl fmt::Display for CullModeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for ImageViewCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; + const KNOWN: &[(Flags, &str)] = &[( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + )]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineCacheHeaderVersion { +impl fmt::Display for DescriptorType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), _ => None, }; if let Some(x) = name { @@ -59972,12 +59168,6 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -60028,14 +59218,157 @@ impl fmt::Display for ObjectType { } } } -impl fmt::Display for ObjectEntryTypeNVX { +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + ( + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -60045,47 +59378,96 @@ impl fmt::Display for ObjectEntryTypeNVX { } } } -impl fmt::Display for QueryResultFlags { +impl fmt::Display for TimeDomainEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RayTracingShaderGroupTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), + (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), + (QueueFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PolygonMode { +impl fmt::Display for ExternalMemoryHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationFeatureEnableEXT { +impl fmt::Display for AttachmentLoadOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GPU_ASSISTED => Some("GPU_ASSISTED"), - Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), _ => None, }; if let Some(x) = name { @@ -60095,38 +59477,110 @@ impl fmt::Display for ValidationFeatureEnableEXT { } } } -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { +impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"), + (AccessFlags::RESERVED_31_KHR.0, "RESERVED_31_KHR"), + (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"), + (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"), + ( + AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, + "SHADING_RATE_IMAGE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, + "ACCELERATION_STRUCTURE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, + "ACCELERATION_STRUCTURE_WRITE_NV", + ), + ( + AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, + "FRAGMENT_DENSITY_MAP_READ_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BorderColor { +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), _ => None, }; if let Some(x) = name { @@ -60136,60 +59590,28 @@ impl fmt::Display for BorderColor { } } } -impl fmt::Display for InternalAllocationType { +impl fmt::Display for AttachmentDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DriverIdKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), - Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), - Self::MESA_RADV => Some("MESA_RADV"), - Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), - Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), - Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), - Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), - Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), - Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), - Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for MemoryHeapFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), ]; display_flags(f, KNOWN, self.0) } @@ -60209,28 +59631,36 @@ impl fmt::Display for SamplerReductionModeEXT { } } } -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { +impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AccelerationStructureTypeNV { +impl fmt::Display for ShadingRatePaletteEntryNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), _ => None, }; if let Some(x) = name { @@ -60240,28 +59670,47 @@ impl fmt::Display for AccelerationStructureTypeNV { } } } -impl fmt::Display for FenceCreateFlags { +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PresentModeKHR { +impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for DebugReportObjectTypeEXT { @@ -60313,6 +59762,405 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESERVED_8 => Some("RESERVED_8"), + Self::RESERVED_4 => Some("RESERVED_4"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ResolveModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ResolveModeFlagsKHR::NONE.0, "NONE"), + (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), + (ResolveModeFlagsKHR::MIN.0, "MIN"), + (ResolveModeFlagsKHR::MAX.0, "MAX"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -60384,24 +60232,52 @@ impl fmt::Display for PipelineStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DynamicState { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), - Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), - Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), _ => None, }; if let Some(x) = name { @@ -60438,11 +60314,14 @@ impl fmt::Display for ExternalSemaphoreHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SharingMode { +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -60452,992 +60331,16 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for ShadingRatePaletteEntryNV { +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), - Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), - Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), - Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), - Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), - Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - ( - SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, - "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::RESERVED_8 => Some("RESERVED_8"), - Self::RESERVED_4 => Some("RESERVED_4"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TimeDomainEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEVICE => Some("DEVICE"), - Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), - Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), - Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), - Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TRIANGLES => Some("TRIANGLES"), - Self::AABBS => Some("AABBS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 34c39fa..30a183b 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1601,7 +1601,7 @@ pub fn derive_setters( /// chain will look like `A -> D -> B -> C`. pub fn push_next(mut self, next: &'a mut T) -> #name_builder<'a> { unsafe{ - let next_ptr = next.as_ptr_mut(); + let next_ptr = next as *mut T as *mut BaseOutStructure; (*next_ptr).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } @@ -1617,7 +1617,6 @@ pub fn derive_setters( let next_trait = if has_next && _struct.extends.is_none() { quote! { pub unsafe trait #extends_name { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure; } } } else { @@ -1628,14 +1627,8 @@ pub fn derive_setters( let impl_extend_trait = if let Some(next_extends) = next_extends { quote! { unsafe impl #next_extends for #name_builder<'_> { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure{ - ::std::mem::transmute(&mut self.inner) - } } unsafe impl #next_extends for #name { - unsafe fn as_ptr_mut(&mut self) -> *mut BaseOutStructure{ - ::std::mem::transmute(self) - } } } } else { @@ -1652,6 +1645,7 @@ pub fn derive_setters( } } + #[repr(transparent)] pub struct #name_builder<'a> { inner: #name, marker: ::std::marker::PhantomData<&'a ()>, From 215511f9cf2e95d5f112da72197b7248b562a64d Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 3 Mar 2019 18:29:37 +0100 Subject: [PATCH 10/21] Implement ExtendXXX for multiple root create infos if there are more than 1 --- ash/src/vk.rs | 3584 +++++++++++++++++++++--------------------- generator/src/lib.rs | 32 +- 2 files changed, 1814 insertions(+), 1802 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index c3b9639..f281454 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -28845,6 +28845,8 @@ pub struct SamplerYcbcrConversionInfoBuilder<'a> { } unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {} +unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {} impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> { type Target = SamplerYcbcrConversionInfo; fn deref(&self) -> &Self::Target { @@ -30939,6 +30941,10 @@ pub struct ImageFormatListCreateInfoKHRBuilder<'a> { } unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHRBuilder<'_> {} unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoKHR {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoKHR {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoKHR {} impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoKHRBuilder<'a> { type Target = ImageFormatListCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -35131,6 +35137,8 @@ pub struct ExternalFormatANDROIDBuilder<'a> { } unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {} unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {} impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> { type Target = ExternalFormatANDROID; fn deref(&self) -> &Self::Target { @@ -38823,6 +38831,8 @@ pub struct ImageStencilUsageCreateInfoEXTBuilder<'a> { } unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXTBuilder<'_> {} unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoEXT {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoEXT {} impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoEXTBuilder<'a> { type Target = ImageStencilUsageCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -56998,30 +57008,835 @@ fn display_flags( } Ok(()) } +impl fmt::Display for TimeDomainEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for FenceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for SamplerCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + ( + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), + (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), + (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), + (ShaderStageFlags::MISS_NV.0, "MISS_NV"), + (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), + (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), + (ShaderStageFlags::TASK_NV.0, "TASK_NV"), + (ShaderStageFlags::MESH_NV.0, "MESH_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryInstanceFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), + (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, + "SHADER_DEVICE_ADDRESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESERVED_8 => Some("RESERVED_8"), + Self::RESERVED_4 => Some("RESERVED_4"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RayTracingShaderGroupTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationFeatureDisableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", ), ]; display_flags(f, KNOWN, self.0) @@ -57294,115 +58109,206 @@ impl fmt::Display for Format { } } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), - ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), - (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), - (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), - (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_BUFFER_EXT", - ), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", - ), - ( - BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), - ( - BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, - "SHADER_DEVICE_ADDRESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VertexInputRate { +impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DriverIdKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, + "LOW_MEMORY", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), _ => None, }; if let Some(x) = name { @@ -57426,191 +58332,15 @@ impl fmt::Display for GeometryTypeNV { } } } -impl fmt::Display for MemoryOverallocationBehaviorAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::ALLOWED => Some("ALLOWED"), - Self::DISALLOWED => Some("DISALLOWED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), - Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), - Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for BlendFactor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57642,11 +58372,10 @@ impl fmt::Display for BlendFactor { } } } -impl fmt::Display for ValidationFeatureEnableEXT { +impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GPU_ASSISTED => Some("GPU_ASSISTED"), - Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), _ => None, }; if let Some(x) = name { @@ -57656,12 +58385,14 @@ impl fmt::Display for ValidationFeatureEnableEXT { } } } -impl fmt::Display for Filter { +impl fmt::Display for SamplerYcbcrModelConversion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), _ => None, }; if let Some(x) = name { @@ -57671,319 +58402,54 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for CommandBufferResetFlags { +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", )]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BuildAccelerationStructureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, - "ALLOW_UPDATE", - ), - ( - BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, - "ALLOW_COMPACTION", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, - "PREFER_FAST_TRACE", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, - "PREFER_FAST_BUILD", - ), - ( - BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, - "LOW_MEMORY", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DriverIdKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), - Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), - Self::MESA_RADV => Some("MESA_RADV"), - Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), - Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), - Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), - Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), - Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), - Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), - Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RenderPassCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccelerationStructureTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationFeatureDisableEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - Self::THREAD_SAFETY => Some("THREAD_SAFETY"), - Self::API_PARAMETERS => Some("API_PARAMETERS"), - Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), - Self::CORE_CHECKS => Some("CORE_CHECKS"), - Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58015,60 +58481,11 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for BlendOp { +impl fmt::Display for DiscardRectangleModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), _ => None, }; if let Some(x) = name { @@ -58078,23 +58495,11 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ViewportCoordinateSwizzleNV { +impl fmt::Display for SharingMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), _ => None, }; if let Some(x) = name { @@ -58104,369 +58509,16 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoarseSampleOrderTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), - (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), - (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), - (ShaderStageFlags::MISS_NV.0, "MISS_NV"), - (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), - (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), - (ShaderStageFlags::TASK_NV.0, "TASK_NV"), - (ShaderStageFlags::MESH_NV.0, "MESH_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BorderColor { +impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), - ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), + Self::EXECUTABLE => Some("EXECUTABLE"), _ => None, }; if let Some(x) = name { @@ -59110,232 +59162,21 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { +impl fmt::Display for DescriptorPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", ), ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - ( - SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, - "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for AttachmentStoreOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59350,16 +59191,269 @@ impl fmt::Display for AttachmentStoreOp { } } } -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", ), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), + (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), + ( + PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ( + PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + PipelineStageFlags::RAY_TRACING_SHADER_NV.0, + "RAY_TRACING_SHADER_NV", + ), + ( + PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, + "ACCELERATION_STRUCTURE_BUILD_NV", + ), + (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), + (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), + ( + PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", ), ]; display_flags(f, KNOWN, self.0) @@ -59378,13 +59472,11 @@ impl fmt::Display for DescriptorUpdateTemplateType { } } } -impl fmt::Display for TimeDomainEXT { +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEVICE => Some("DEVICE"), - Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), - Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), - Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), _ => None, }; if let Some(x) = name { @@ -59394,10 +59486,14 @@ impl fmt::Display for TimeDomainEXT { } } } -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -59407,18 +59503,11 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for ConditionalRenderingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RayTracingShaderGroupTypeNV { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), _ => None, }; if let Some(x) = name { @@ -59428,11 +59517,13 @@ impl fmt::Display for RayTracingShaderGroupTypeNV { } } } -impl fmt::Display for FrontFace { +impl fmt::Display for PolygonMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), _ => None, }; if let Some(x) = name { @@ -59442,41 +59533,32 @@ impl fmt::Display for FrontFace { } } } -impl fmt::Display for QueueFlags { +impl fmt::Display for SubpassDescriptionFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), - (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), - (QueueFlags::PROTECTED.0, "PROTECTED"), + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalMemoryHandleTypeFlags { +impl fmt::Display for CompositeAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for AccessFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59570,17 +59652,20 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for StencilOp { +impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), _ => None, }; if let Some(x) = name { @@ -59590,57 +59675,25 @@ impl fmt::Display for StencilOp { } } } -impl fmt::Display for AttachmentDescriptionFlags { +impl fmt::Display for CommandBufferResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { +impl fmt::Display for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", ), ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) @@ -59670,143 +59723,6 @@ impl fmt::Display for ShadingRatePaletteEntryNV { } } } -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::RESERVED_8 => Some("RESERVED_8"), - Self::RESERVED_4 => Some("RESERVED_4"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59830,12 +59746,35 @@ impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageType { +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), _ => None, }; if let Some(x) = name { @@ -59845,149 +59784,17 @@ impl fmt::Display for ImageType { } } } -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - ( - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, - "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", - ), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), _ => None, }; if let Some(x) = name { @@ -60009,34 +59816,23 @@ impl fmt::Display for ResolveModeFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineCreateFlags { +impl fmt::Display for CommandPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { +impl fmt::Display for ValidationCacheHeaderVersionEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OBJECT => Some("OBJECT"), - Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), - Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + Self::ONE => Some("ONE"), _ => None, }; if let Some(x) = name { @@ -60046,11 +59842,11 @@ impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { } } } -impl fmt::Display for DiscardRectangleModeEXT { +impl fmt::Display for ValidationFeatureEnableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), _ => None, }; if let Some(x) = name { @@ -60060,6 +59856,76 @@ impl fmt::Display for DiscardRectangleModeEXT { } } } +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for TessellationDomainOrigin { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -60074,22 +59940,6 @@ impl fmt::Display for TessellationDomainOrigin { } } } -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for DescriptorBindingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -60113,18 +59963,61 @@ impl fmt::Display for DescriptorBindingFlagsEXT { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for QueryPipelineStatisticFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for ImageCreateFlags { @@ -60161,77 +60054,132 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineStageFlags { +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", ), ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), + (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), + (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), - (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), - ( - PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, - "TRANSFORM_FEEDBACK_EXT", - ), - ( - PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ( - PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, "SHADING_RATE_IMAGE_NV", ), ( - PipelineStageFlags::RAY_TRACING_SHADER_NV.0, - "RAY_TRACING_SHADER_NV", - ), - ( - PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, - "ACCELERATION_STRUCTURE_BUILD_NV", - ), - (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), - (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), - ( - PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, - "FRAGMENT_DENSITY_PROCESS_EXT", + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccelerationStructureTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -60245,16 +60193,12 @@ impl fmt::Display for PipelineCacheHeaderVersion { } } } -impl fmt::Display for SwapchainCreateFlagsKHR { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - ]; + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } @@ -60272,56 +60216,30 @@ impl fmt::Display for DeviceGroupPresentModeFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", ), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", ), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for CopyAccelerationStructureModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), _ => None, }; if let Some(x) = name { @@ -60331,16 +60249,10 @@ impl fmt::Display for PhysicalDeviceType { } } } -impl fmt::Display for ImageViewType { +impl fmt::Display for DeviceEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), _ => None, }; if let Some(x) = name { @@ -60350,6 +60262,104 @@ impl fmt::Display for ImageViewType { } } } +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), + (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags; diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 30a183b..55cd071 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1583,16 +1583,20 @@ pub fn derive_setters( let extends_name = name_to_tokens(&format!("Extends{}", name)); - let next_extends = _struct.extends.as_ref().map(|extends| { - let extends = extends - .split(',') - .find(|extend| root_create_info_names.contains(&extend.to_string())) - .expect("Should have a root create info"); - name_to_tokens(&format!("Extends{}", name_to_tokens(&extends))) - }); + let root_extends: Vec = _struct + .extends + .as_ref() + .map(|extends| { + extends + .split(',') + .filter(|extend| root_create_info_names.contains(&extend.to_string())) + .map(|extends| name_to_tokens(&format!("Extends{}", name_to_tokens(&extends)))) + .collect() + }) + .unwrap_or(vec![]); // We only implement a next methods for root create infos - let next_function = if has_next && next_extends.is_none() { + let next_function = if has_next && root_extends.is_empty() { quote! { /// Prepends the given extension struct between the root and the first pointer. This /// method only exists on create infos that can be passed to a function directly. Only @@ -1624,16 +1628,14 @@ pub fn derive_setters( }; // If the struct extends something we need to implement the root create info trait. - let impl_extend_trait = if let Some(next_extends) = next_extends { + let impl_extend_trait = root_extends.iter().map(|extends| { quote! { - unsafe impl #next_extends for #name_builder<'_> { + unsafe impl #extends for #name_builder<'_> { } - unsafe impl #next_extends for #name { + unsafe impl #extends for #name { } } - } else { - quote! {} - }; + }); let q = quote! { impl #name { @@ -1651,7 +1653,7 @@ pub fn derive_setters( marker: ::std::marker::PhantomData<&'a ()>, } - #impl_extend_trait + #(#impl_extend_trait)* #next_trait From 04dbf20371463658e3f6eb1bf53631ff22f398be Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 4 Mar 2019 09:56:53 +0100 Subject: [PATCH 11/21] Transform the ptr chain sample into a test case --- ash/src/vk.rs | 3764 +++++++++++++++++++++--------------------- examples/src/lib.rs | 13 - generator/src/lib.rs | 61 +- 3 files changed, 1938 insertions(+), 1900 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index f281454..1bb8c7e 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,21 +1,5 @@ use std::fmt; use std::os::raw::*; -#[doc = r" `T` has to be a valid xxx_create_info struct. Addtionally all the pointer chains in"] -#[doc = r" this iterator are mutable. Make sure that all the objects in this pointer chain have an"] -#[doc = r" active `&mut` borrow if you want to update those objects."] -pub unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { - use std::ptr::null_mut; - let ptr: *mut BaseOutStructure = ::std::mem::transmute(ptr); - (0..).scan(ptr, |p_ptr, _| { - if *p_ptr == null_mut() { - return None; - } - let n_ptr = (**p_ptr).p_next as *mut BaseOutStructure; - let old = *p_ptr; - *p_ptr = n_ptr; - Some(old) - }) -} pub trait Handle { const TYPE: ObjectType; fn as_raw(self) -> u64; @@ -57008,49 +56992,71 @@ fn display_flags( } Ok(()) } -impl fmt::Display for TimeDomainEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEVICE => Some("DEVICE"), - Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), - Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), - Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerCreateFlags { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, - "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BorderColor { +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), _ => None, }; if let Some(x) = name { @@ -57060,22 +57066,94 @@ impl fmt::Display for BorderColor { } } } -impl fmt::Display for DescriptorType { +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), _ => None, }; if let Some(x) = name { @@ -57098,6 +57176,397 @@ impl fmt::Display for StencilFaceFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ResolveModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ResolveModeFlagsKHR::NONE.0, "NONE"), + (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), + (ResolveModeFlagsKHR::MIN.0, "MIN"), + (ResolveModeFlagsKHR::MAX.0, "MAX"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57113,6 +57582,493 @@ impl fmt::Display for DebugReportFlagsEXT { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CopyAccelerationStructureModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESERVED_8 => Some("RESERVED_8"), + Self::RESERVED_4 => Some("RESERVED_4"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), + (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, + "SHADER_DEVICE_ADDRESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"), + (AccessFlags::RESERVED_31_KHR.0, "RESERVED_31_KHR"), + (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"), + (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"), + ( + AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, + "SHADING_RATE_IMAGE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, + "ACCELERATION_STRUCTURE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, + "ACCELERATION_STRUCTURE_WRITE_NV", + ), + ( + AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, + "FRAGMENT_DENSITY_MAP_READ_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57205,327 +58161,6 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RenderPassCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConditionalRenderingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for MemoryOverallocationBehaviorAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57541,74 +58176,26 @@ impl fmt::Display for MemoryOverallocationBehaviorAMD { } } } -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), - (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_BUFFER_EXT", - ), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", - ), - ( - BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), - ( - BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, - "SHADER_DEVICE_ADDRESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerYcbcrRange { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), _ => None, }; if let Some(x) = name { @@ -57633,91 +58220,6 @@ impl fmt::Display for AttachmentLoadOp { } } } -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57732,18 +58234,13 @@ impl fmt::Display for DisplayPlaneAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryType { +impl fmt::Display for TimeDomainEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::RESERVED_8 => Some("RESERVED_8"), - Self::RESERVED_4 => Some("RESERVED_4"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") - } + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), _ => None, }; if let Some(x) = name { @@ -57753,59 +58250,51 @@ impl fmt::Display for QueryType { } } } -impl fmt::Display for RayTracingShaderGroupTypeNV { +impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationFeatureDisableEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - Self::THREAD_SAFETY => Some("THREAD_SAFETY"), - Self::API_PARAMETERS => Some("API_PARAMETERS"), - Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), - Self::CORE_CHECKS => Some("CORE_CHECKS"), - Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OBJECT => Some("OBJECT"), - Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), - Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), _ => None, }; if let Some(x) = name { @@ -57815,33 +58304,24 @@ impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { } } } -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { +impl fmt::Display for SamplerCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58109,12 +58589,16 @@ impl fmt::Display for Format { } } } -impl fmt::Display for IndexType { +impl fmt::Display for ValidationFeatureDisableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), _ => None, }; if let Some(x) = name { @@ -58124,6 +58608,12 @@ impl fmt::Display for IndexType { } } } +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58139,6 +58629,52 @@ impl fmt::Display for ShaderInfoTypeAMD { } } } +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for SubgroupFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -58155,13 +58691,28 @@ impl fmt::Display for SubgroupFeatureFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), _ => None, }; if let Some(x) = name { @@ -58171,34 +58722,77 @@ impl fmt::Display for SamplerAddressMode { } } } -impl fmt::Display for ExternalMemoryFeatureFlagsNV { +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", ), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PresentModeKHR { +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -58230,178 +58824,6 @@ impl fmt::Display for DriverIdKHR { } } } -impl fmt::Display for BuildAccelerationStructureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, - "ALLOW_UPDATE", - ), - ( - BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, - "ALLOW_COMPACTION", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, - "PREFER_FAST_TRACE", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, - "PREFER_FAST_BUILD", - ), - ( - BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, - "LOW_MEMORY", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), - ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TRIANGLES => Some("TRIANGLES"), - Self::AABBS => Some("AABBS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendFactor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58422,16 +58844,15 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for ComponentSwizzle { +impl fmt::Display for BorderColor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), _ => None, }; if let Some(x) = name { @@ -58441,37 +58862,13 @@ impl fmt::Display for ComponentSwizzle { } } } -impl fmt::Display for ImageViewCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { +impl fmt::Display for CoverageModulationModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), - Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), _ => None, }; if let Some(x) = name { @@ -58481,40 +58878,6 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58528,6 +58891,149 @@ impl fmt::Display for InternalAllocationType { } } } +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RayTracingShaderGroupTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59162,26 +59668,84 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for DescriptorPoolCreateFlags { +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", ), ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AttachmentStoreOp { +impl fmt::Display for ColorSpaceKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), _ => None, }; if let Some(x) = name { @@ -59191,12 +59755,34 @@ impl fmt::Display for AttachmentStoreOp { } } } -impl fmt::Display for ImageTiling { +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationFeatureEnableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), _ => None, }; if let Some(x) = name { @@ -59206,6 +59792,186 @@ impl fmt::Display for ImageTiling { } } } +impl fmt::Display for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShadingRatePaletteEntryNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccelerationStructureTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), + (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), + (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), + ( + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, + "LOW_MEMORY", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for DescriptorSetLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59221,13 +59987,47 @@ impl fmt::Display for DescriptorSetLayoutCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueueGlobalPriorityEXT { +impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -59237,13 +60037,16 @@ impl fmt::Display for QueueGlobalPriorityEXT { } } } -impl fmt::Display for CoarseSampleOrderTypeNV { +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { @@ -59253,6 +60056,158 @@ impl fmt::Display for CoarseSampleOrderTypeNV { } } } +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59324,702 +60279,6 @@ impl fmt::Display for PipelineStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccessFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", - ), - ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", - ), - ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"), - (AccessFlags::RESERVED_31_KHR.0, "RESERVED_31_KHR"), - (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"), - (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"), - ( - AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_WRITE_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", - ), - ( - AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, - "CONDITIONAL_RENDERING_READ_EXT", - ), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ( - AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, - "SHADING_RATE_IMAGE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, - "ACCELERATION_STRUCTURE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, - "ACCELERATION_STRUCTURE_WRITE_NV", - ), - ( - AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, - "FRAGMENT_DENSITY_MAP_READ_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShadingRatePaletteEntryNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), - Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), - Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), - Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), - Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), - Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ResolveModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ResolveModeFlagsKHR::NONE.0, "NONE"), - (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), - (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), - (ResolveModeFlagsKHR::MIN.0, "MIN"), - (ResolveModeFlagsKHR::MAX.0, "MAX"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ValidationFeatureEnableEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GPU_ASSISTED => Some("GPU_ASSISTED"), - Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -60054,268 +60313,14 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DynamicState { +impl fmt::Display for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), - Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), - Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), - (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), - (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccelerationStructureTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - ( - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, - "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", - ), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), _ => None, }; if let Some(x) = name { @@ -60339,27 +60344,6 @@ impl fmt::Display for QueueFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags; @@ -60445,3 +60429,41 @@ pub type SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; +#[cfg(test)] +mod tests { + use vk; + #[test] + fn test_ptr_chains() { + unsafe fn ptr_chain_iter( + ptr: &mut T, + ) -> impl Iterator { + use std::ptr::null_mut; + let ptr: *mut vk::BaseOutStructure = ptr as *mut T as _; + let ptr: *mut vk::BaseOutStructure = (*ptr).p_next; + (0..).scan(ptr, |p_ptr, _| { + if *p_ptr == null_mut() { + return None; + } + let n_ptr = (**p_ptr).p_next as *mut vk::BaseOutStructure; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) + } + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); + let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); + let chain = vec![ + &variable_pointers as *const _ as usize, + &corner as *const _ as usize, + ]; + let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); + let chain2: Vec = unsafe { + ptr_chain_iter(&mut device_create_info) + .map(|ptr| ptr as usize) + .collect() + }; + assert_eq!(chain, chain2); + } +} diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 75fef77..cb200a7 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -406,25 +406,12 @@ impl ExampleBase { .queue_priorities(&priorities) .build()]; - let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder() - .variable_pointers(true) - .build(); - let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder() - .corner_sampled_image(true); let mut device_create_info = vk::DeviceCreateInfo::builder() - .push_next(&mut corner) - .push_next(&mut variable_pointers) .queue_create_infos(&queue_info) .enabled_extension_names(&device_extension_names_raw) .enabled_features(&features) .build(); - for ptr in vk::ptr_chain_iter(&mut device_create_info) { - println!("{:?}", ptr); - } - println!("--"); - println!("{:?}", &corner as *const _); - println!("{:?}", &variable_pointers as *const _); let device: Device = instance .create_device(pdevice, &device_create_info, None) .unwrap(); diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 55cd071..30e3048 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -85,6 +85,49 @@ named!(cfloat<&str, f32>, terminated!(nom::float_s, char!('f')) ); +pub fn define_test() -> Tokens { + quote! { + #[cfg(test)] + mod tests { + use vk; + #[test] + fn test_ptr_chains() { + unsafe fn ptr_chain_iter( + ptr: &mut T, + ) -> impl Iterator { + use std::ptr::null_mut; + let ptr: *mut vk::BaseOutStructure = ptr as *mut T as _; + let ptr: *mut vk::BaseOutStructure = (*ptr).p_next; + (0..).scan(ptr, |p_ptr, _| { + if *p_ptr == null_mut() { + return None; + } + let n_ptr = (**p_ptr).p_next as *mut vk::BaseOutStructure; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) + } + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); + let mut corner = + vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); + let chain = vec![ + &variable_pointers as *const _ as usize, + &corner as *const _ as usize, + ]; + let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); + let chain2: Vec = unsafe { + ptr_chain_iter(&mut device_create_info) + .map(|ptr| ptr as usize) + .collect() + }; + assert_eq!(chain, chain2); + } + } + } +} pub fn define_handle_macro() -> Tokens { quote! { #[macro_export] @@ -2194,25 +2237,10 @@ pub fn write_source_code(path: &Path) { let define_handle_macro = define_handle_macro(); let version_macros = vk_version_macros(); let platform_specific_types = platform_specific_types(); + let define_test = define_test(); let source_code = quote! { use std::fmt; use std::os::raw::*; - /// `T` has to be a valid xxx_create_info struct. Addtionally all the pointer chains in - /// this iterator are mutable. Make sure that all the objects in this pointer chain have an - /// active `&mut` borrow if you want to update those objects. - pub unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { - use std::ptr::null_mut; - let ptr: *mut BaseOutStructure = ::std::mem::transmute(ptr); - (0..).scan(ptr, |p_ptr, _|{ - if *p_ptr == null_mut() { - return None; - } - let n_ptr = (**p_ptr).p_next as *mut BaseOutStructure; - let old = *p_ptr; - *p_ptr = n_ptr; - Some(old) - }) - } pub trait Handle { const TYPE: ObjectType; @@ -2234,6 +2262,7 @@ pub fn write_source_code(path: &Path) { #feature_extensions_code #const_displays #(#aliases)* + #define_test }; write!(&mut file, "{}", source_code).expect("Unable to write to file"); } From 2ecc48388dfec7a303a370cf786f904d319c1a13 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 4 Mar 2019 09:59:54 +0100 Subject: [PATCH 12/21] Reformat experimental amd --- ash/src/extensions/experimental/amd.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/ash/src/extensions/experimental/amd.rs b/ash/src/extensions/experimental/amd.rs index 08f0f8d..f37f6de 100644 --- a/ash/src/extensions/experimental/amd.rs +++ b/ash/src/extensions/experimental/amd.rs @@ -208,10 +208,8 @@ pub struct PhysicalDeviceGpaPropertiesAmdBuilder<'a> { inner: PhysicalDeviceGpaPropertiesAmd, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceGpaPropertiesAmd { -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGpaPropertiesAmd { -} +pub unsafe trait ExtendsPhysicalDeviceGpaPropertiesAmd {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGpaPropertiesAmd {} impl<'a> ::std::ops::Deref for PhysicalDeviceGpaPropertiesAmdBuilder<'a> { type Target = PhysicalDeviceGpaPropertiesAmd; fn deref(&self) -> &Self::Target { @@ -650,10 +648,8 @@ pub struct PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { inner: PhysicalDeviceWaveLimitPropertiesAmd, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceWaveLimitPropertiesAmd { -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceWaveLimitPropertiesAmd { -} +pub unsafe trait ExtendsPhysicalDeviceWaveLimitPropertiesAmd {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceWaveLimitPropertiesAmd {} impl<'a> ::std::ops::Deref for PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { type Target = PhysicalDeviceWaveLimitPropertiesAmd; fn deref(&self) -> &Self::Target { From 4c1c8aa64850c8a38a7c475a4c1a04f36225b852 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 4 Mar 2019 10:16:08 +0100 Subject: [PATCH 13/21] Remove mut --- examples/src/lib.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/examples/src/lib.rs b/examples/src/lib.rs index cb200a7..9c45999 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -406,11 +406,10 @@ impl ExampleBase { .queue_priorities(&priorities) .build()]; - let mut device_create_info = vk::DeviceCreateInfo::builder() + let device_create_info = vk::DeviceCreateInfo::builder() .queue_create_infos(&queue_info) .enabled_extension_names(&device_extension_names_raw) - .enabled_features(&features) - .build(); + .enabled_features(&features); let device: Device = instance .create_device(pdevice, &device_create_info, None) From 88b1ac077d523bb224a71d4528f35aace0178b14 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Mon, 4 Mar 2019 10:22:38 +0100 Subject: [PATCH 14/21] Rename root_extends --- generator/src/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 30e3048..0b82cd5 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1626,7 +1626,7 @@ pub fn derive_setters( let extends_name = name_to_tokens(&format!("Extends{}", name)); - let root_extends: Vec = _struct + let root_extensions: Vec = _struct .extends .as_ref() .map(|extends| { @@ -1639,7 +1639,7 @@ pub fn derive_setters( .unwrap_or(vec![]); // We only implement a next methods for root create infos - let next_function = if has_next && root_extends.is_empty() { + let next_function = if has_next && root_extensions.is_empty() { quote! { /// Prepends the given extension struct between the root and the first pointer. This /// method only exists on create infos that can be passed to a function directly. Only @@ -1671,7 +1671,7 @@ pub fn derive_setters( }; // If the struct extends something we need to implement the root create info trait. - let impl_extend_trait = root_extends.iter().map(|extends| { + let impl_extend_trait = root_extensions.iter().map(|extends| { quote! { unsafe impl #extends for #name_builder<'_> { } From d667e583583e61e60dcc999e2f0cdb7e757a1a07 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 9 Mar 2019 17:33:42 +0100 Subject: [PATCH 15/21] Add example --- README.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/README.md b/README.md index 586cd93..4daa8d2 100644 --- a/README.md +++ b/README.md @@ -82,6 +82,23 @@ Builders implement `Deref` targeting their corresponding Vulkan struct, so refer to Vulkan functions. This is encouraged as doing so allows Rust to check the lifetimes of captured objects are valid, whereas calling `build` discards lifetime information, making inadvertent use-after-free errors more likely. +### Pointer chains + +```Rust +let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); +let mut corner = + vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); +; +let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); +``` + +Pointer chains in builders differ from raw Vulkan. Instead of chaining every struct manually, you instead use `.push_next` on the struct that you are going to pass into the function. Those structs then get *pepended* into the chain. + +`push_next` is also type checked, you can only add valid structs to the chain. Both the structs and the builders can be passed into `push_next`. Only builders for structs that can be passed into functions will implement a `push_next`. + + ### Flags and constants as associated constants ```Rust From bf29ebb39de8fcb7ad82949f15c5261e05daec20 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 9 Mar 2019 17:34:10 +0100 Subject: [PATCH 16/21] Replace root create info with root_struct --- generator/src/lib.rs | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 0b82cd5..a4aa7c2 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1423,7 +1423,7 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt pub fn derive_setters( _struct: &vkxml::Struct, - root_create_info_names: &HashSet, + root_struct_names: &HashSet, ) -> Option { if &_struct.name == "VkBaseInStructure" || &_struct.name == "VkBaseOutStructure" { return None; @@ -1626,23 +1626,23 @@ pub fn derive_setters( let extends_name = name_to_tokens(&format!("Extends{}", name)); - let root_extensions: Vec = _struct + let root_structs: Vec = _struct .extends .as_ref() .map(|extends| { extends .split(',') - .filter(|extend| root_create_info_names.contains(&extend.to_string())) + .filter(|extend| root_struct_names.contains(&extend.to_string())) .map(|extends| name_to_tokens(&format!("Extends{}", name_to_tokens(&extends)))) .collect() }) .unwrap_or(vec![]); - // We only implement a next methods for root create infos - let next_function = if has_next && root_extensions.is_empty() { + // We only implement a next methods for root structs with a `pnext` field. + let next_function = if has_next && root_structs.is_empty() { quote! { /// Prepends the given extension struct between the root and the first pointer. This - /// method only exists on create infos that can be passed to a function directly. Only + /// method only exists on structs that can be passed to a function directly. Only /// valid extension structs can be pushed into the chain. /// If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the /// chain will look like `A -> D -> B -> C`. @@ -1659,7 +1659,7 @@ pub fn derive_setters( quote! {} }; - // Root create infos come with their own trait that structs that extends this create info will + // Root structs come with their own trait that structs that extends this struct will // implement let next_trait = if has_next && _struct.extends.is_none() { quote! { @@ -1670,8 +1670,8 @@ pub fn derive_setters( quote! {} }; - // If the struct extends something we need to implement the root create info trait. - let impl_extend_trait = root_extensions.iter().map(|extends| { + // If the struct extends something we need to implement the trait. + let impl_extend_trait = root_structs.iter().map(|extends| { quote! { unsafe impl #extends for #name_builder<'_> { } @@ -1740,7 +1740,7 @@ pub fn manual_derives(_struct: &vkxml::Struct) -> Tokens { } pub fn generate_struct( _struct: &vkxml::Struct, - root_create_info_names: &HashSet, + root_struct_names: &HashSet, union_types: &HashSet<&str>, ) -> Tokens { let name = name_to_tokens(&_struct.name); @@ -1757,7 +1757,7 @@ pub fn generate_struct( let debug_tokens = derive_debug(_struct, union_types); let default_tokens = derive_default(_struct); - let setter_tokens = derive_setters(_struct, root_create_info_names); + let setter_tokens = derive_setters(_struct, root_struct_names); let manual_derive_tokens = manual_derives(_struct); let dbg_str = if debug_tokens.is_none() { quote!(Debug,) @@ -1843,13 +1843,13 @@ fn generate_union(union: &vkxml::Union) -> Tokens { } } } -pub fn root_create_info_names(definitions: &[&vkxml::DefinitionsElement]) -> HashSet { +pub fn root_struct_names(definitions: &[&vkxml::DefinitionsElement]) -> HashSet { definitions .iter() .filter_map(|definition| match *definition { vkxml::DefinitionsElement::Struct(ref _struct) => { - let is_root_create_info = _struct.extends.is_none(); - if is_root_create_info { + let is_root_struct = _struct.extends.is_none(); + if is_root_struct { Some(_struct.name.clone()) } else { None @@ -1862,14 +1862,14 @@ pub fn root_create_info_names(definitions: &[&vkxml::DefinitionsElement]) -> Has pub fn generate_definition( definition: &vkxml::DefinitionsElement, union_types: &HashSet<&str>, - root_create_info_names: &HashSet, + root_structs: &HashSet, bitflags_cache: &mut HashSet, ) -> Option { match *definition { vkxml::DefinitionsElement::Typedef(ref typedef) => Some(generate_typedef(typedef)), vkxml::DefinitionsElement::Struct(ref _struct) => Some(generate_struct( _struct, - root_create_info_names, + root_structs, union_types, )), vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask, bitflags_cache), @@ -2209,14 +2209,14 @@ pub fn write_source_code(path: &Path) { }) .collect::>(); - let root_create_info_names = root_create_info_names(&definitions); + let root_names = root_struct_names(&definitions); let definition_code: Vec<_> = definitions .into_iter() .filter_map(|def| { generate_definition( def, &union_types, - &root_create_info_names, + &root_names, &mut bitflags_cache, ) }) From c8c8f69a7c89f4e5996b4aeabeea0a6380f65169 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 9 Mar 2019 18:52:03 +0100 Subject: [PATCH 17/21] `next` can contain a pointer chain and we need to correct insert it. --- ash/src/vk.rs | 4155 ++++++++++++++++++++++-------------------- generator/src/lib.rs | 64 +- 2 files changed, 2186 insertions(+), 2033 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 1bb8c7e..fd3d81d 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,5 +1,18 @@ use std::fmt; use std::os::raw::*; +pub(crate) unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { + use std::ptr::null_mut; + let ptr: *mut BaseOutStructure = ptr as *mut T as _; + (0..).scan(ptr, |p_ptr, _| { + if *p_ptr == null_mut() { + return None; + } + let n_ptr = (**p_ptr).p_next as *mut BaseOutStructure; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) +} pub trait Handle { const TYPE: ObjectType; fn as_raw(self) -> u64; @@ -8334,7 +8347,7 @@ impl<'a> ApplicationInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -8344,7 +8357,8 @@ impl<'a> ApplicationInfoBuilder<'a> { ) -> ApplicationInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -8532,7 +8546,7 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -8542,7 +8556,8 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> { ) -> DeviceQueueCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -8643,7 +8658,7 @@ impl<'a> DeviceCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -8653,7 +8668,8 @@ impl<'a> DeviceCreateInfoBuilder<'a> { ) -> DeviceCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -8742,7 +8758,7 @@ impl<'a> InstanceCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -8752,7 +8768,8 @@ impl<'a> InstanceCreateInfoBuilder<'a> { ) -> InstanceCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -8948,7 +8965,7 @@ impl<'a> MemoryAllocateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -8958,7 +8975,8 @@ impl<'a> MemoryAllocateInfoBuilder<'a> { ) -> MemoryAllocateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -9290,7 +9308,7 @@ impl<'a> MappedMemoryRangeBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -9300,7 +9318,8 @@ impl<'a> MappedMemoryRangeBuilder<'a> { ) -> MappedMemoryRangeBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -9626,7 +9645,7 @@ impl<'a> WriteDescriptorSetBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -9636,7 +9655,8 @@ impl<'a> WriteDescriptorSetBuilder<'a> { ) -> WriteDescriptorSetBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -9728,7 +9748,7 @@ impl<'a> CopyDescriptorSetBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -9738,7 +9758,8 @@ impl<'a> CopyDescriptorSetBuilder<'a> { ) -> CopyDescriptorSetBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -9824,7 +9845,7 @@ impl<'a> BufferCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -9834,7 +9855,8 @@ impl<'a> BufferCreateInfoBuilder<'a> { ) -> BufferCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -9914,7 +9936,7 @@ impl<'a> BufferViewCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -9924,7 +9946,8 @@ impl<'a> BufferViewCreateInfoBuilder<'a> { ) -> BufferViewCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -10151,7 +10174,7 @@ impl<'a> MemoryBarrierBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -10161,7 +10184,8 @@ impl<'a> MemoryBarrierBuilder<'a> { ) -> MemoryBarrierBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -10265,7 +10289,7 @@ impl<'a> BufferMemoryBarrierBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -10275,7 +10299,8 @@ impl<'a> BufferMemoryBarrierBuilder<'a> { ) -> BufferMemoryBarrierBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -10388,7 +10413,7 @@ impl<'a> ImageMemoryBarrierBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -10398,7 +10423,8 @@ impl<'a> ImageMemoryBarrierBuilder<'a> { ) -> ImageMemoryBarrierBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -10526,7 +10552,7 @@ impl<'a> ImageCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -10536,7 +10562,8 @@ impl<'a> ImageCreateInfoBuilder<'a> { ) -> ImageCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -10683,7 +10710,7 @@ impl<'a> ImageViewCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -10693,7 +10720,8 @@ impl<'a> ImageViewCreateInfoBuilder<'a> { ) -> ImageViewCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -11143,7 +11171,7 @@ impl<'a> BindSparseInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -11153,7 +11181,8 @@ impl<'a> BindSparseInfoBuilder<'a> { ) -> BindSparseInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -11481,7 +11510,7 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -11491,7 +11520,8 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> { ) -> ShaderModuleCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -11644,7 +11674,7 @@ impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -11654,7 +11684,8 @@ impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { ) -> DescriptorSetLayoutCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -11774,7 +11805,7 @@ impl<'a> DescriptorPoolCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -11784,7 +11815,8 @@ impl<'a> DescriptorPoolCreateInfoBuilder<'a> { ) -> DescriptorPoolCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -11855,7 +11887,7 @@ impl<'a> DescriptorSetAllocateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -11865,7 +11897,8 @@ impl<'a> DescriptorSetAllocateInfoBuilder<'a> { ) -> DescriptorSetAllocateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12059,7 +12092,7 @@ impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12069,7 +12102,8 @@ impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { ) -> PipelineShaderStageCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12158,7 +12192,7 @@ impl<'a> ComputePipelineCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12168,7 +12202,8 @@ impl<'a> ComputePipelineCreateInfoBuilder<'a> { ) -> ComputePipelineCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12355,7 +12390,7 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12365,7 +12400,8 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { ) -> PipelineVertexInputStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12442,7 +12478,7 @@ impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12452,7 +12488,8 @@ impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12520,7 +12557,7 @@ impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12530,7 +12567,8 @@ impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { ) -> PipelineTessellationStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12627,7 +12665,7 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12637,7 +12675,8 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { ) -> PipelineViewportStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12786,7 +12825,7 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12796,7 +12835,8 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { ) -> PipelineRasterizationStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -12909,7 +12949,7 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -12919,7 +12959,8 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { ) -> PipelineMultisampleStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -13111,7 +13152,7 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -13121,7 +13162,8 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { ) -> PipelineColorBlendStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -13192,7 +13234,7 @@ impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -13202,7 +13244,8 @@ impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { ) -> PipelineDynamicStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -13407,7 +13450,7 @@ impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -13417,7 +13460,8 @@ impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -13602,7 +13646,7 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -13612,7 +13656,8 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { ) -> GraphicsPipelineCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -13677,7 +13722,7 @@ impl<'a> PipelineCacheCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -13687,7 +13732,8 @@ impl<'a> PipelineCacheCreateInfoBuilder<'a> { ) -> PipelineCacheCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -13818,7 +13864,7 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -13828,7 +13874,8 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> { ) -> PipelineLayoutCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -13986,7 +14033,7 @@ impl<'a> SamplerCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -13996,7 +14043,8 @@ impl<'a> SamplerCreateInfoBuilder<'a> { ) -> SamplerCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -14061,7 +14109,7 @@ impl<'a> CommandPoolCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -14071,7 +14119,8 @@ impl<'a> CommandPoolCreateInfoBuilder<'a> { ) -> CommandPoolCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -14145,7 +14194,7 @@ impl<'a> CommandBufferAllocateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -14155,7 +14204,8 @@ impl<'a> CommandBufferAllocateInfoBuilder<'a> { ) -> CommandBufferAllocateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -14256,7 +14306,7 @@ impl<'a> CommandBufferInheritanceInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -14266,7 +14316,8 @@ impl<'a> CommandBufferInheritanceInfoBuilder<'a> { ) -> CommandBufferInheritanceInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -14331,7 +14382,7 @@ impl<'a> CommandBufferBeginInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -14341,7 +14392,8 @@ impl<'a> CommandBufferBeginInfoBuilder<'a> { ) -> CommandBufferBeginInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -14434,7 +14486,7 @@ impl<'a> RenderPassBeginInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -14444,7 +14496,8 @@ impl<'a> RenderPassBeginInfoBuilder<'a> { ) -> RenderPassBeginInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -14975,7 +15028,7 @@ impl<'a> RenderPassCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -14985,7 +15038,8 @@ impl<'a> RenderPassCreateInfoBuilder<'a> { ) -> RenderPassCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -15041,7 +15095,7 @@ impl<'a> EventCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -15051,7 +15105,8 @@ impl<'a> EventCreateInfoBuilder<'a> { ) -> EventCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -15107,7 +15162,7 @@ impl<'a> FenceCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -15117,7 +15172,8 @@ impl<'a> FenceCreateInfoBuilder<'a> { ) -> FenceCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -16679,7 +16735,7 @@ impl<'a> SemaphoreCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -16689,7 +16745,8 @@ impl<'a> SemaphoreCreateInfoBuilder<'a> { ) -> SemaphoreCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -16766,7 +16823,7 @@ impl<'a> QueryPoolCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -16776,7 +16833,8 @@ impl<'a> QueryPoolCreateInfoBuilder<'a> { ) -> QueryPoolCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -16865,7 +16923,7 @@ impl<'a> FramebufferCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -16875,7 +16933,8 @@ impl<'a> FramebufferCreateInfoBuilder<'a> { ) -> FramebufferCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -17127,14 +17186,15 @@ impl<'a> SubmitInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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) -> SubmitInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -17442,7 +17502,7 @@ impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -17452,7 +17512,8 @@ impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { ) -> DisplayModeCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -17673,7 +17734,7 @@ impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -17683,7 +17744,8 @@ impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -17915,7 +17977,7 @@ impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -17925,7 +17987,8 @@ impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -17987,7 +18050,7 @@ impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -17997,7 +18060,8 @@ impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { ) -> ViSurfaceCreateInfoNNBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -18068,7 +18132,7 @@ impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -18078,7 +18142,8 @@ impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -18149,7 +18214,7 @@ impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -18159,7 +18224,8 @@ impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { ) -> Win32SurfaceCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -18230,7 +18296,7 @@ impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -18240,7 +18306,8 @@ impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { ) -> XlibSurfaceCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -18311,7 +18378,7 @@ impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -18321,7 +18388,8 @@ impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { ) -> XcbSurfaceCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -18389,7 +18457,7 @@ impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -18399,7 +18467,8 @@ impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -18612,7 +18681,7 @@ impl<'a> SwapchainCreateInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -18622,7 +18691,8 @@ impl<'a> SwapchainCreateInfoKHRBuilder<'a> { ) -> SwapchainCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -18707,7 +18777,7 @@ impl<'a> PresentInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -18717,7 +18787,8 @@ impl<'a> PresentInfoKHRBuilder<'a> { ) -> PresentInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -19060,7 +19131,7 @@ impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -19070,7 +19141,8 @@ impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -19150,7 +19222,7 @@ impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -19160,7 +19232,8 @@ impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -19225,7 +19298,7 @@ impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -19235,7 +19308,8 @@ impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { ) -> DebugMarkerMarkerInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -19851,7 +19925,7 @@ impl<'a> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -19861,7 +19935,8 @@ impl<'a> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { ) -> DeviceGeneratedCommandsFeaturesNVXBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -19960,7 +20035,7 @@ impl<'a> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -19970,7 +20045,8 @@ impl<'a> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { ) -> DeviceGeneratedCommandsLimitsNVXBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -20160,7 +20236,7 @@ impl<'a> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -20170,7 +20246,8 @@ impl<'a> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { ) -> IndirectCommandsLayoutCreateInfoNVXBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -20304,7 +20381,7 @@ impl<'a> CmdProcessCommandsInfoNVXBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -20314,7 +20391,8 @@ impl<'a> CmdProcessCommandsInfoNVXBuilder<'a> { ) -> CmdProcessCommandsInfoNVXBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -20391,7 +20469,7 @@ impl<'a> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -20401,7 +20479,8 @@ impl<'a> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { ) -> CmdReserveSpaceForCommandsInfoNVXBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -20528,7 +20607,7 @@ impl<'a> ObjectTableCreateInfoNVXBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -20538,7 +20617,8 @@ impl<'a> ObjectTableCreateInfoNVXBuilder<'a> { ) -> ObjectTableCreateInfoNVXBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -20979,7 +21059,7 @@ impl<'a> PhysicalDeviceProperties2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -20989,7 +21069,8 @@ impl<'a> PhysicalDeviceProperties2Builder<'a> { ) -> PhysicalDeviceProperties2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -21048,7 +21129,7 @@ impl<'a> FormatProperties2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -21058,7 +21139,8 @@ impl<'a> FormatProperties2Builder<'a> { ) -> FormatProperties2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -21117,7 +21199,7 @@ impl<'a> ImageFormatProperties2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -21127,7 +21209,8 @@ impl<'a> ImageFormatProperties2Builder<'a> { ) -> ImageFormatProperties2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -21207,7 +21290,7 @@ impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -21217,7 +21300,8 @@ impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { ) -> PhysicalDeviceImageFormatInfo2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -21276,7 +21360,7 @@ impl<'a> QueueFamilyProperties2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -21286,7 +21370,8 @@ impl<'a> QueueFamilyProperties2Builder<'a> { ) -> QueueFamilyProperties2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -21345,7 +21430,7 @@ impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -21355,7 +21440,8 @@ impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { ) -> PhysicalDeviceMemoryProperties2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -21414,7 +21500,7 @@ impl<'a> SparseImageFormatProperties2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -21424,7 +21510,8 @@ impl<'a> SparseImageFormatProperties2Builder<'a> { ) -> SparseImageFormatProperties2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -21513,7 +21600,7 @@ impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -21523,7 +21610,8 @@ impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -22185,7 +22273,7 @@ impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -22195,7 +22283,8 @@ impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -22254,7 +22343,7 @@ impl<'a> ExternalBufferPropertiesBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -22264,7 +22353,8 @@ impl<'a> ExternalBufferPropertiesBuilder<'a> { ) -> ExternalBufferPropertiesBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -22707,7 +22797,7 @@ impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -22717,7 +22807,8 @@ impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -22782,7 +22873,7 @@ impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -22792,7 +22883,8 @@ impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -22908,7 +23000,7 @@ impl<'a> MemoryFdPropertiesKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -22918,7 +23010,8 @@ impl<'a> MemoryFdPropertiesKHRBuilder<'a> { ) -> MemoryFdPropertiesKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -22983,7 +23076,7 @@ impl<'a> MemoryGetFdInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -22993,7 +23086,8 @@ impl<'a> MemoryGetFdInfoKHRBuilder<'a> { ) -> MemoryGetFdInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23151,7 +23245,7 @@ impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23161,7 +23255,8 @@ impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23238,7 +23333,7 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23248,7 +23343,8 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> { ) -> ExternalSemaphorePropertiesBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23391,7 +23487,7 @@ impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23401,7 +23497,8 @@ impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23601,7 +23698,7 @@ impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23611,7 +23708,8 @@ impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23688,7 +23786,7 @@ impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23698,7 +23796,8 @@ impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { ) -> ImportSemaphoreFdInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23763,7 +23862,7 @@ impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23773,7 +23872,8 @@ impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { ) -> SemaphoreGetFdInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23832,7 +23932,7 @@ impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23842,7 +23942,8 @@ impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -23919,7 +24020,7 @@ impl<'a> ExternalFencePropertiesBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -23929,7 +24030,8 @@ impl<'a> ExternalFencePropertiesBuilder<'a> { ) -> ExternalFencePropertiesBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24066,7 +24168,7 @@ impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24076,7 +24178,8 @@ impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24207,7 +24310,7 @@ impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24217,7 +24320,8 @@ impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { ) -> FenceGetWin32HandleInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24294,7 +24398,7 @@ impl<'a> ImportFenceFdInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24304,7 +24408,8 @@ impl<'a> ImportFenceFdInfoKHRBuilder<'a> { ) -> ImportFenceFdInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24369,7 +24474,7 @@ impl<'a> FenceGetFdInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24379,7 +24484,8 @@ impl<'a> FenceGetFdInfoKHRBuilder<'a> { ) -> FenceGetFdInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24732,7 +24838,7 @@ impl<'a> SurfaceCapabilities2EXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24742,7 +24848,8 @@ impl<'a> SurfaceCapabilities2EXTBuilder<'a> { ) -> SurfaceCapabilities2EXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24801,7 +24908,7 @@ impl<'a> DisplayPowerInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24811,7 +24918,8 @@ impl<'a> DisplayPowerInfoEXTBuilder<'a> { ) -> DisplayPowerInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24870,7 +24978,7 @@ impl<'a> DeviceEventInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24880,7 +24988,8 @@ impl<'a> DeviceEventInfoEXTBuilder<'a> { ) -> DeviceEventInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -24939,7 +25048,7 @@ impl<'a> DisplayEventInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -24949,7 +25058,8 @@ impl<'a> DisplayEventInfoEXTBuilder<'a> { ) -> DisplayEventInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -25080,7 +25190,7 @@ impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -25090,7 +25200,8 @@ impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { ) -> PhysicalDeviceGroupPropertiesBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -25215,7 +25326,7 @@ impl<'a> BindBufferMemoryInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -25225,7 +25336,8 @@ impl<'a> BindBufferMemoryInfoBuilder<'a> { ) -> BindBufferMemoryInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -25350,7 +25462,7 @@ impl<'a> BindImageMemoryInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -25360,7 +25472,8 @@ impl<'a> BindImageMemoryInfoBuilder<'a> { ) -> BindImageMemoryInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -25755,7 +25868,7 @@ impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -25765,7 +25878,8 @@ impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -25956,7 +26070,7 @@ impl<'a> AcquireNextImageInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -25966,7 +26080,8 @@ impl<'a> AcquireNextImageInfoKHRBuilder<'a> { ) -> AcquireNextImageInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -26325,7 +26440,7 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -26335,7 +26450,8 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -26491,7 +26607,7 @@ impl<'a> HdrMetadataEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -26501,7 +26617,8 @@ impl<'a> HdrMetadataEXTBuilder<'a> { ) -> HdrMetadataEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -26774,7 +26891,7 @@ impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -26784,7 +26901,8 @@ impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { ) -> IOSSurfaceCreateInfoMVKBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -26849,7 +26967,7 @@ impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -26859,7 +26977,8 @@ impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27455,7 +27574,7 @@ impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27465,7 +27584,8 @@ impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { ) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27524,7 +27644,7 @@ impl<'a> SurfaceCapabilities2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27534,7 +27654,8 @@ impl<'a> SurfaceCapabilities2KHRBuilder<'a> { ) -> SurfaceCapabilities2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27593,7 +27714,7 @@ impl<'a> SurfaceFormat2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27603,7 +27724,8 @@ impl<'a> SurfaceFormat2KHRBuilder<'a> { ) -> SurfaceFormat2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27662,7 +27784,7 @@ impl<'a> DisplayProperties2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27672,7 +27794,8 @@ impl<'a> DisplayProperties2KHRBuilder<'a> { ) -> DisplayProperties2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27731,7 +27854,7 @@ impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27741,7 +27864,8 @@ impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { ) -> DisplayPlaneProperties2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27800,7 +27924,7 @@ impl<'a> DisplayModeProperties2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27810,7 +27934,8 @@ impl<'a> DisplayModeProperties2KHRBuilder<'a> { ) -> DisplayModeProperties2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27872,7 +27997,7 @@ impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27882,7 +28007,8 @@ impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { ) -> DisplayPlaneInfo2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -27941,7 +28067,7 @@ impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -27951,7 +28077,8 @@ impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { ) -> DisplayPlaneCapabilities2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -28224,7 +28351,7 @@ impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -28234,7 +28361,8 @@ impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { ) -> BufferMemoryRequirementsInfo2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -28290,7 +28418,7 @@ impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -28300,7 +28428,8 @@ impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { ) -> ImageMemoryRequirementsInfo2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -28356,7 +28485,7 @@ impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -28366,7 +28495,8 @@ impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { ) -> ImageSparseMemoryRequirementsInfo2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -28425,7 +28555,7 @@ impl<'a> MemoryRequirements2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -28435,7 +28565,8 @@ impl<'a> MemoryRequirements2Builder<'a> { ) -> MemoryRequirements2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -28494,7 +28625,7 @@ impl<'a> SparseImageMemoryRequirements2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -28504,7 +28635,8 @@ impl<'a> SparseImageMemoryRequirements2Builder<'a> { ) -> SparseImageMemoryRequirements2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -28964,7 +29096,7 @@ impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -28974,7 +29106,8 @@ impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -29320,7 +29453,7 @@ impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -29330,7 +29463,8 @@ impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { ) -> ConditionalRenderingBeginInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -29560,7 +29694,7 @@ impl<'a> DeviceQueueInfo2Builder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -29570,7 +29704,8 @@ impl<'a> DeviceQueueInfo2Builder<'a> { ) -> DeviceQueueInfo2Builder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -30218,7 +30353,7 @@ impl<'a> MultisamplePropertiesEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -30228,7 +30363,8 @@ impl<'a> MultisamplePropertiesEXTBuilder<'a> { ) -> MultisamplePropertiesEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -31015,7 +31151,7 @@ impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -31025,7 +31161,8 @@ impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { ) -> ValidationCacheCreateInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -31198,7 +31335,7 @@ impl<'a> DescriptorSetLayoutSupportBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -31208,7 +31345,8 @@ impl<'a> DescriptorSetLayoutSupportBuilder<'a> { ) -> DescriptorSetLayoutSupportBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -31603,7 +31741,7 @@ impl<'a> NativeBufferANDROIDBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -31613,7 +31751,8 @@ impl<'a> NativeBufferANDROIDBuilder<'a> { ) -> NativeBufferANDROIDBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -31910,7 +32049,7 @@ impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -31920,7 +32059,8 @@ impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -31997,7 +32137,7 @@ impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -32007,7 +32147,8 @@ impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { ) -> DebugUtilsObjectTagInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -32069,7 +32210,7 @@ impl<'a> DebugUtilsLabelEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -32079,7 +32220,8 @@ impl<'a> DebugUtilsLabelEXTBuilder<'a> { ) -> DebugUtilsLabelEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -32307,7 +32449,7 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -32317,7 +32459,8 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -32439,7 +32582,7 @@ impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -32449,7 +32592,8 @@ impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { ) -> MemoryHostPointerPropertiesEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -32702,7 +32846,7 @@ impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -32712,7 +32856,8 @@ impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { ) -> CalibratedTimestampInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -33812,7 +33957,7 @@ impl<'a> AttachmentDescription2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -33822,7 +33967,8 @@ impl<'a> AttachmentDescription2KHRBuilder<'a> { ) -> AttachmentDescription2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -33893,7 +34039,7 @@ impl<'a> AttachmentReference2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -33903,7 +34049,8 @@ impl<'a> AttachmentReference2KHRBuilder<'a> { ) -> AttachmentReference2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -34029,7 +34176,7 @@ impl<'a> SubpassDescription2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -34039,7 +34186,8 @@ impl<'a> SubpassDescription2KHRBuilder<'a> { ) -> SubpassDescription2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -34152,7 +34300,7 @@ impl<'a> SubpassDependency2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -34162,7 +34310,8 @@ impl<'a> SubpassDependency2KHRBuilder<'a> { ) -> SubpassDependency2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -34266,7 +34415,7 @@ impl<'a> RenderPassCreateInfo2KHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -34276,7 +34425,8 @@ impl<'a> RenderPassCreateInfo2KHRBuilder<'a> { ) -> RenderPassCreateInfo2KHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -34332,7 +34482,7 @@ impl<'a> SubpassBeginInfoKHRBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -34342,7 +34492,8 @@ impl<'a> SubpassBeginInfoKHRBuilder<'a> { ) -> SubpassBeginInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -34392,7 +34543,7 @@ impl<'a> ::std::ops::DerefMut for SubpassEndInfoKHRBuilder<'a> { } impl<'a> SubpassEndInfoKHRBuilder<'a> { #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -34402,7 +34553,8 @@ impl<'a> SubpassEndInfoKHRBuilder<'a> { ) -> SubpassEndInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -34819,7 +34971,7 @@ impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -34829,7 +34981,8 @@ impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -34888,7 +35041,7 @@ impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -34898,7 +35051,8 @@ impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -35580,7 +35734,7 @@ impl<'a> CheckpointDataNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -35590,7 +35744,8 @@ impl<'a> CheckpointDataNVBuilder<'a> { ) -> CheckpointDataNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -37401,7 +37556,7 @@ impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -37411,7 +37566,8 @@ impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -37527,7 +37683,7 @@ impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -37537,7 +37693,8 @@ impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { ) -> RayTracingPipelineCreateInfoNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -37656,7 +37813,7 @@ impl<'a> GeometryTrianglesNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -37666,7 +37823,8 @@ impl<'a> GeometryTrianglesNVBuilder<'a> { ) -> GeometryTrianglesNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -37740,7 +37898,7 @@ impl<'a> GeometryAABBNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -37750,7 +37908,8 @@ impl<'a> GeometryAABBNVBuilder<'a> { ) -> GeometryAABBNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -37861,14 +38020,15 @@ impl<'a> GeometryNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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) -> GeometryNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -37951,7 +38111,7 @@ impl<'a> AccelerationStructureInfoNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -37961,7 +38121,8 @@ impl<'a> AccelerationStructureInfoNVBuilder<'a> { ) -> AccelerationStructureInfoNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -38029,7 +38190,7 @@ impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -38039,7 +38200,8 @@ impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { ) -> AccelerationStructureCreateInfoNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -38128,7 +38290,7 @@ impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -38138,7 +38300,8 @@ impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -38263,7 +38426,7 @@ impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -38273,7 +38436,8 @@ impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -38765,7 +38929,7 @@ impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -38775,7 +38939,8 @@ impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -39441,7 +39606,7 @@ impl<'a> BufferDeviceAddressInfoEXTBuilder<'a> { self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on create infos that can be passed to a function directly. Only"] + #[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`."] @@ -39451,7 +39616,8 @@ impl<'a> BufferDeviceAddressInfoEXTBuilder<'a> { ) -> BufferDeviceAddressInfoEXTBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -56992,71 +57158,13 @@ fn display_flags( } Ok(()) } -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -57066,15 +57174,108 @@ impl fmt::Display for PointClippingBehavior { } } } -impl fmt::Display for CommandPoolResetFlags { +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccelerationStructureTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", )]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for LogicOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57103,26 +57304,22 @@ impl fmt::Display for LogicOp { } } } -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { +impl fmt::Display for ColorComponentFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndexType { +impl fmt::Display for AttachmentStoreOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), _ => None, }; if let Some(x) = name { @@ -57132,28 +57329,17 @@ impl fmt::Display for IndexType { } } } -impl fmt::Display for BlendFactor { +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { + Self::KEEP => Some("KEEP"), Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), _ => None, }; if let Some(x) = name { @@ -57163,188 +57349,13 @@ impl fmt::Display for BlendFactor { } } } -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { +impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ResolveModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ResolveModeFlagsKHR::NONE.0, "NONE"), - (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), - (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), - (ResolveModeFlagsKHR::MIN.0, "MIN"), - (ResolveModeFlagsKHR::MAX.0, "MAX"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), _ => None, }; if let Some(x) = name { @@ -57382,31 +57393,11 @@ impl fmt::Display for SurfaceTransformFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::NEAREST => Some("NEAREST"), Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -57416,50 +57407,36 @@ impl fmt::Display for Filter { } } } -impl fmt::Display for CommandBufferUsageFlags { +impl fmt::Display for ResolveModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), + (ResolveModeFlagsKHR::NONE.0, "NONE"), + (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), + (ResolveModeFlagsKHR::MIN.0, "MIN"), + (ResolveModeFlagsKHR::MAX.0, "MAX"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryPropertyFlags { +impl fmt::Display for QueueFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), + (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), + (QueueFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrRange { +impl fmt::Display for SparseMemoryBindFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for DebugReportObjectTypeEXT { @@ -57511,6 +57488,34 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } +impl fmt::Display for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57526,12 +57531,28 @@ impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { } } } -impl fmt::Display for ImageTiling { +impl fmt::Display for BlendFactor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), _ => None, }; if let Some(x) = name { @@ -57541,14 +57562,27 @@ impl fmt::Display for ImageTiling { } } } -impl fmt::Display for SamplerYcbcrModelConversion { +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), _ => None, }; if let Some(x) = name { @@ -57558,6 +57592,231 @@ impl fmt::Display for SamplerYcbcrModelConversion { } } } +impl fmt::Display for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -57567,224 +57826,65 @@ impl fmt::Display for ObjectEntryUsageFlagsNVX { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DebugReportFlagsEXT { +impl fmt::Display for AttachmentLoadOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubpassDescriptionFlags { +impl fmt::Display for ExternalMemoryFeatureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", ), ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TRIANGLES => Some("TRIANGLES"), - Self::AABBS => Some("AABBS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), - Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), - Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for MemoryPropertyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { +impl fmt::Display for ConservativeRasterizationModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ONE => Some("ONE"), + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), _ => None, }; if let Some(x) = name { @@ -57794,49 +57894,12 @@ impl fmt::Display for ValidationCacheHeaderVersionEXT { } } } -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { +impl fmt::Display for BlendOverlapEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), _ => None, }; if let Some(x) = name { @@ -57846,24 +57909,26 @@ impl fmt::Display for CompareOp { } } } -impl fmt::Display for SemaphoreImportFlags { +impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for QueryType { +impl fmt::Display for PrimitiveTopology { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::RESERVED_8 => Some("RESERVED_8"), - Self::RESERVED_4 => Some("RESERVED_4"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") - } + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), _ => None, }; if let Some(x) = name { @@ -57873,54 +57938,11 @@ impl fmt::Display for QueryType { } } } -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), - (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_BUFFER_EXT", - ), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", - ), - ( - BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), - ( - BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, - "SHADER_DEVICE_ADDRESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { +impl fmt::Display for TessellationDomainOrigin { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), _ => None, }; if let Some(x) = name { @@ -58023,6 +58045,76 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58054,12 +58146,24 @@ impl fmt::Display for ImageLayout { } } } -impl fmt::Display for ImageType { +impl fmt::Display for DynamicState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), _ => None, }; if let Some(x) = name { @@ -58069,89 +58173,217 @@ impl fmt::Display for ImageType { } } } -impl fmt::Display for ShaderStageFlags { +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DriverIdKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), - (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), - (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), - (ShaderStageFlags::MISS_NV.0, "MISS_NV"), - (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), - (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), - (ShaderStageFlags::TASK_NV.0, "TASK_NV"), - (ShaderStageFlags::MESH_NV.0, "MESH_NV"), + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BlendOp { +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for InternalAllocationType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), + Self::EXECUTABLE => Some("EXECUTABLE"), _ => None, }; if let Some(x) = name { @@ -58161,12 +58393,12 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for MemoryOverallocationBehaviorAMD { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::ALLOWED => Some("ALLOWED"), - Self::DISALLOWED => Some("DISALLOWED"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), _ => None, }; if let Some(x) = name { @@ -58176,11 +58408,16 @@ impl fmt::Display for MemoryOverallocationBehaviorAMD { } } } -impl fmt::Display for ValidationCheckEXT { +impl fmt::Display for ComponentSwizzle { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), _ => None, }; if let Some(x) = name { @@ -58190,12 +58427,37 @@ impl fmt::Display for ValidationCheckEXT { } } } -impl fmt::Display for VendorId { +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -58205,12 +58467,37 @@ impl fmt::Display for VendorId { } } } -impl fmt::Display for AttachmentLoadOp { +impl fmt::Display for CoverageModulationModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RayTracingShaderGroupTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), _ => None, }; if let Some(x) = name { @@ -58234,6 +58521,71 @@ impl fmt::Display for DisplayPlaneAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ValidationFeatureEnableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for TimeDomainEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58250,51 +58602,12 @@ impl fmt::Display for TimeDomainEXT { } } } -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompositeAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineBindPoint { +impl fmt::Display for ImageTiling { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), _ => None, }; if let Some(x) = name { @@ -58304,21 +58617,12 @@ impl fmt::Display for PipelineBindPoint { } } } -impl fmt::Display for SamplerCreateFlags { +impl fmt::Display for CommandPoolResetFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - ( - SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, - "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; display_flags(f, KNOWN, self.0) } } @@ -58589,241 +58893,40 @@ impl fmt::Display for Format { } } } -impl fmt::Display for ValidationFeatureDisableEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - Self::THREAD_SAFETY => Some("THREAD_SAFETY"), - Self::API_PARAMETERS => Some("API_PARAMETERS"), - Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), - Self::CORE_CHECKS => Some("CORE_CHECKS"), - Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CoarseSampleOrderTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ConditionalRenderingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ImageCreateFlags::ALIAS.0, "ALIAS"), ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", ), ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - ( - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, - "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", - ), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DriverIdKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), - Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), - Self::MESA_RADV => Some("MESA_RADV"), - Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), - Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), - Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), - Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), - Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), - Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), - Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58844,15 +58947,11 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for BorderColor { +impl fmt::Display for PointClippingBehavior { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), _ => None, }; if let Some(x) = name { @@ -58862,13 +58961,18 @@ impl fmt::Display for BorderColor { } } } -impl fmt::Display for CoverageModulationModeNV { +impl fmt::Display for QueryType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESERVED_8 => Some("RESERVED_8"), + Self::RESERVED_4 => Some("RESERVED_4"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } _ => None, }; if let Some(x) = name { @@ -58878,153 +58982,11 @@ impl fmt::Display for CoverageModulationModeNV { } } } -impl fmt::Display for InternalAllocationType { +impl fmt::Display for SamplerYcbcrRange { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RayTracingShaderGroupTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConservativeRasterizationModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), _ => None, }; if let Some(x) = name { @@ -59668,93 +59630,49 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for BufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", ), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), + (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, + "SHADER_DEVICE_ADDRESS_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for ExternalFenceHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59778,11 +59696,16 @@ impl fmt::Display for ExternalFenceHandleTypeFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationFeatureEnableEXT { +impl fmt::Display for ImageViewType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GPU_ASSISTED => Some("GPU_ASSISTED"), - Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), _ => None, }; if let Some(x) = name { @@ -59792,13 +59715,74 @@ impl fmt::Display for ValidationFeatureEnableEXT { } } } -impl fmt::Display for RenderPassCreateFlags { +impl fmt::Display for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationFeatureDisableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for ShadingRatePaletteEntryNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59823,391 +59807,6 @@ impl fmt::Display for ShadingRatePaletteEntryNV { } } } -impl fmt::Display for AccelerationStructureTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), - (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), - (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BuildAccelerationStructureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, - "ALLOW_UPDATE", - ), - ( - BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, - "ALLOW_COMPACTION", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, - "PREFER_FAST_TRACE", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, - "PREFER_FAST_BUILD", - ), - ( - BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, - "LOW_MEMORY", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for PipelineStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -60279,48 +59878,11 @@ impl fmt::Display for PipelineStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { +impl fmt::Display for CopyAccelerationStructureModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), _ => None, }; if let Some(x) = name { @@ -60330,20 +59892,624 @@ impl fmt::Display for PhysicalDeviceType { } } } -impl fmt::Display for QueueFlags { +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), - (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), - (QueueFlags::PROTECTED.0, "PROTECTED"), + ( + BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, + "LOW_MEMORY", + ), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), + (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), + (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), + (ShaderStageFlags::MISS_NV.0, "MISS_NV"), + (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), + (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), + (ShaderStageFlags::TASK_NV.0, "TASK_NV"), + (ShaderStageFlags::MESH_NV.0, "MESH_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), + (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), + (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), + ( + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + ( + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags; @@ -60434,22 +60600,6 @@ mod tests { use vk; #[test] fn test_ptr_chains() { - unsafe fn ptr_chain_iter( - ptr: &mut T, - ) -> impl Iterator { - use std::ptr::null_mut; - let ptr: *mut vk::BaseOutStructure = ptr as *mut T as _; - let ptr: *mut vk::BaseOutStructure = (*ptr).p_next; - (0..).scan(ptr, |p_ptr, _| { - if *p_ptr == null_mut() { - return None; - } - let n_ptr = (**p_ptr).p_next as *mut vk::BaseOutStructure; - let old = *p_ptr; - *p_ptr = n_ptr; - Some(old) - }) - } let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); let chain = vec![ @@ -60460,7 +60610,8 @@ mod tests { .push_next(&mut corner) .push_next(&mut variable_pointers); let chain2: Vec = unsafe { - ptr_chain_iter(&mut device_create_info) + vk::ptr_chain_iter(&mut device_create_info) + .skip(1) .map(|ptr| ptr as usize) .collect() }; diff --git a/generator/src/lib.rs b/generator/src/lib.rs index a4aa7c2..4078516 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -92,22 +92,6 @@ pub fn define_test() -> Tokens { use vk; #[test] fn test_ptr_chains() { - unsafe fn ptr_chain_iter( - ptr: &mut T, - ) -> impl Iterator { - use std::ptr::null_mut; - let ptr: *mut vk::BaseOutStructure = ptr as *mut T as _; - let ptr: *mut vk::BaseOutStructure = (*ptr).p_next; - (0..).scan(ptr, |p_ptr, _| { - if *p_ptr == null_mut() { - return None; - } - let n_ptr = (**p_ptr).p_next as *mut vk::BaseOutStructure; - let old = *p_ptr; - *p_ptr = n_ptr; - Some(old) - }) - } let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); @@ -119,7 +103,7 @@ pub fn define_test() -> Tokens { .push_next(&mut corner) .push_next(&mut variable_pointers); let chain2: Vec = unsafe { - ptr_chain_iter(&mut device_create_info) + vk::ptr_chain_iter(&mut device_create_info).skip(1) .map(|ptr| ptr as usize) .collect() }; @@ -1649,7 +1633,17 @@ pub fn derive_setters( pub fn push_next(mut self, next: &'a mut T) -> #name_builder<'a> { unsafe{ let next_ptr = next as *mut T as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + // `next` here can contain a pointer chain. This means that we must correctly + // attach he head to the root and the tail to the rest of the chain + // For example: + // + // next = A -> B + // Before: `Root -> C -> D -> E` + // After: `Root -> A -> B -> C -> D -> E` + // ^^^^^^ + // next chain + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self @@ -1867,11 +1861,9 @@ pub fn generate_definition( ) -> Option { match *definition { vkxml::DefinitionsElement::Typedef(ref typedef) => Some(generate_typedef(typedef)), - vkxml::DefinitionsElement::Struct(ref _struct) => Some(generate_struct( - _struct, - root_structs, - union_types, - )), + vkxml::DefinitionsElement::Struct(ref _struct) => { + Some(generate_struct(_struct, root_structs, union_types)) + } vkxml::DefinitionsElement::Bitmask(ref mask) => generate_bitmask(mask, bitflags_cache), vkxml::DefinitionsElement::Handle(ref handle) => generate_handle(handle), vkxml::DefinitionsElement::FuncPtr(ref fp) => Some(generate_funcptr(fp)), @@ -2212,14 +2204,7 @@ pub fn write_source_code(path: &Path) { let root_names = root_struct_names(&definitions); let definition_code: Vec<_> = definitions .into_iter() - .filter_map(|def| { - generate_definition( - def, - &union_types, - &root_names, - &mut bitflags_cache, - ) - }) + .filter_map(|def| generate_definition(def, &union_types, &root_names, &mut bitflags_cache)) .collect(); let feature_code: Vec<_> = features @@ -2241,6 +2226,23 @@ pub fn write_source_code(path: &Path) { let source_code = quote! { use std::fmt; use std::os::raw::*; + // Iterates through the pointer chain. Includes the item that is passed into the function. + // Stops at the last `BaseOutStructure` that has a null `p_next` field. + pub(crate) unsafe fn ptr_chain_iter( + ptr: &mut T, + ) -> impl Iterator { + use std::ptr::null_mut; + let ptr: *mut BaseOutStructure = ptr as *mut T as _; + (0..).scan(ptr, |p_ptr, _| { + if *p_ptr == null_mut() { + return None; + } + let n_ptr = (**p_ptr).p_next as *mut BaseOutStructure; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) + } pub trait Handle { const TYPE: ObjectType; From 1744159dfdb2d098d5e074a1097fc190a9f8a963 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 9 Mar 2019 19:05:31 +0100 Subject: [PATCH 18/21] Move ptr chain tests out of the generator --- ash/src/vk.rs | 3775 +++++++++++++++++++++--------------------- generator/src/lib.rs | 35 +- 2 files changed, 1880 insertions(+), 1930 deletions(-) diff --git a/ash/src/vk.rs b/ash/src/vk.rs index fd3d81d..859c62f 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -1,6 +1,8 @@ use std::fmt; use std::os::raw::*; -pub(crate) unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { +#[doc = r" Iterates through the pointer chain. Includes the item that is passed into the function."] +#[doc = r" Stops at the last `BaseOutStructure` that has a null `p_next` field."] +pub unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { use std::ptr::null_mut; let ptr: *mut BaseOutStructure = ptr as *mut T as _; (0..).scan(ptr, |p_ptr, _| { @@ -57158,13 +57160,12 @@ fn display_flags( } Ok(()) } -impl fmt::Display for SamplerAddressMode { +impl fmt::Display for IndexType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), _ => None, }; if let Some(x) = name { @@ -57174,24 +57175,47 @@ impl fmt::Display for SamplerAddressMode { } } } -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PolygonMode { +impl fmt::Display for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, }; if let Some(x) = name { @@ -57201,11 +57225,12 @@ impl fmt::Display for PolygonMode { } } } -impl fmt::Display for AccelerationStructureTypeNV { +impl fmt::Display for PipelineBindPoint { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), _ => None, }; if let Some(x) = name { @@ -57215,230 +57240,6 @@ impl fmt::Display for AccelerationStructureTypeNV { } } } -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorComponentFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueueGlobalPriorityEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOW => Some("LOW"), - Self::MEDIUM => Some("MEDIUM"), - Self::HIGH => Some("HIGH"), - Self::REALTIME => Some("REALTIME"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceTransformFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), - (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), - (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), - (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, - "HORIZONTAL_MIRROR", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, - "HORIZONTAL_MIRROR_ROTATE_90", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, - "HORIZONTAL_MIRROR_ROTATE_180", - ), - ( - SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, - "HORIZONTAL_MIRROR_ROTATE_270", - ), - (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ResolveModeFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ResolveModeFlagsKHR::NONE.0, "NONE"), - (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), - (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), - (ResolveModeFlagsKHR::MIN.0, "MIN"), - (ResolveModeFlagsKHR::MAX.0, "MAX"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), - (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for DebugReportObjectTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -57488,71 +57289,16 @@ impl fmt::Display for DebugReportObjectTypeEXT { } } } -impl fmt::Display for CoarseSampleOrderTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), - ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OBJECT => Some("OBJECT"), - Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), - Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendFactor { +impl fmt::Display for ComponentSwizzle { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { + Self::IDENTITY => Some("IDENTITY"), Self::ZERO => Some("ZERO"), Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), _ => None, }; if let Some(x) = name { @@ -57562,27 +57308,14 @@ impl fmt::Display for BlendFactor { } } } -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { +impl fmt::Display for ObjectEntryTypeNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), _ => None, }; if let Some(x) = name { @@ -57592,63 +57325,26 @@ impl fmt::Display for DiscardRectangleModeEXT { } } } -impl fmt::Display for RenderPassCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for DescriptorPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", ), ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorSpaceKHR { +impl fmt::Display for ValidationFeatureEnableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), _ => None, }; if let Some(x) = name { @@ -57658,12 +57354,139 @@ impl fmt::Display for ColorSpaceKHR { } } } -impl fmt::Display for IndexType { +impl fmt::Display for GeometryInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilOp { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), _ => None, }; if let Some(x) = name { @@ -57736,12 +57559,20 @@ impl fmt::Display for BlendOp { } } } -impl fmt::Display for ShaderInfoTypeAMD { +impl fmt::Display for ImageViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DiscardRectangleModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), _ => None, }; if let Some(x) = name { @@ -57751,131 +57582,9 @@ impl fmt::Display for ShaderInfoTypeAMD { } } } -impl fmt::Display for ImageType { +impl fmt::Display for FenceImportFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SampleCountFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ConditionalRenderingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", - ), - ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; display_flags(f, KNOWN, self.0) } } @@ -57894,200 +57603,42 @@ impl fmt::Display for ConservativeRasterizationModeEXT { } } } -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for FenceImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PrimitiveTopology { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccessFlags { +impl fmt::Display for ExternalFenceHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - AccessFlags::INDIRECT_COMMAND_READ.0, - "INDIRECT_COMMAND_READ", - ), - (AccessFlags::INDEX_READ.0, "INDEX_READ"), - ( - AccessFlags::VERTEX_ATTRIBUTE_READ.0, - "VERTEX_ATTRIBUTE_READ", - ), - (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), - ( - AccessFlags::INPUT_ATTACHMENT_READ.0, - "INPUT_ATTACHMENT_READ", - ), - (AccessFlags::SHADER_READ.0, "SHADER_READ"), - (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), - ( - AccessFlags::COLOR_ATTACHMENT_READ.0, - "COLOR_ATTACHMENT_READ", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", ), ( - AccessFlags::COLOR_ATTACHMENT_WRITE.0, - "COLOR_ATTACHMENT_WRITE", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", ), ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, - "DEPTH_STENCIL_ATTACHMENT_READ", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", ), ( - AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, - "DEPTH_STENCIL_ATTACHMENT_WRITE", - ), - (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), - (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), - (AccessFlags::HOST_READ.0, "HOST_READ"), - (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), - (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), - (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), - (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"), - (AccessFlags::RESERVED_31_KHR.0, "RESERVED_31_KHR"), - (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"), - (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"), - ( - AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_WRITE_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", - ), - ( - AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", - ), - ( - AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, - "CONDITIONAL_RENDERING_READ_EXT", - ), - ( - AccessFlags::COMMAND_PROCESS_READ_NVX.0, - "COMMAND_PROCESS_READ_NVX", - ), - ( - AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, - "COMMAND_PROCESS_WRITE_NVX", - ), - ( - AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, - "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", - ), - ( - AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, - "SHADING_RATE_IMAGE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, - "ACCELERATION_STRUCTURE_READ_NV", - ), - ( - AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, - "ACCELERATION_STRUCTURE_WRITE_NV", - ), - ( - AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, - "FRAGMENT_DENSITY_MAP_READ_EXT", + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for FrontFace { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58102,322 +57653,83 @@ impl fmt::Display for FrontFace { } } } -impl fmt::Display for DisplayEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), - Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), - Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), - Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DriverIdKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), - Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), - Self::MESA_RADV => Some("MESA_RADV"), - Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), - Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), - Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), - Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), - Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), - Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), - Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SubgroupFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { +impl fmt::Display for ImageUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), + (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), + (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), + ( + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", ), ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalMemoryFeatureFlags { +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for InternalAllocationType { +impl fmt::Display for PipelineCacheHeaderVersion { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), _ => None, }; if let Some(x) = name { @@ -58427,37 +57739,24 @@ impl fmt::Display for ComponentSwizzle { } } } -impl fmt::Display for DescriptorBindingFlagsEXT { +impl fmt::Display for SamplerCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ObjectEntryTypeNVX { +impl fmt::Display for ImageType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), _ => None, }; if let Some(x) = name { @@ -58483,21 +57782,21 @@ impl fmt::Display for CoverageModulationModeNV { } } } -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RayTracingShaderGroupTypeNV { +impl fmt::Display for ShadingRatePaletteEntryNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), _ => None, }; if let Some(x) = name { @@ -58507,25 +57806,83 @@ impl fmt::Display for RayTracingShaderGroupTypeNV { } } } -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { +impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationFeatureEnableEXT { +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GPU_ASSISTED => Some("GPU_ASSISTED"), - Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), _ => None, }; if let Some(x) = name { @@ -58535,97 +57892,6 @@ impl fmt::Display for ValidationFeatureEnableEXT { } } } -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for TimeDomainEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEVICE => Some("DEVICE"), - Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), - Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), - Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CommandPoolResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandPoolResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for Format { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -58893,51 +58159,40 @@ impl fmt::Display for Format { } } } -impl fmt::Display for ImageCreateFlags { +impl fmt::Display for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryPropertyFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), - (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), - ( - ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, - "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", - ), - (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - (ImageCreateFlags::ALIAS.0, "ALIAS"), - ( - ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - ( - ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, - "TYPE_2D_ARRAY_COMPATIBLE", - ), - ( - ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, - "BLOCK_TEXEL_VIEW_COMPATIBLE", - ), - (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), - (ImageCreateFlags::PROTECTED.0, "PROTECTED"), - (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ViewportCoordinateSwizzleNV { +impl fmt::Display for ValidationCheckEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), _ => None, }; if let Some(x) = name { @@ -58947,32 +58202,12 @@ impl fmt::Display for ViewportCoordinateSwizzleNV { } } } -impl fmt::Display for PointClippingBehavior { +impl fmt::Display for SamplerReductionModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::RESERVED_8 => Some("RESERVED_8"), - Self::RESERVED_4 => Some("RESERVED_4"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") - } + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), _ => None, }; if let Some(x) = name { @@ -58996,6 +58231,197 @@ impl fmt::Display for SamplerYcbcrRange { } } } +impl fmt::Display for DriverIdKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), + (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), + ( + PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ( + PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + PipelineStageFlags::RAY_TRACING_SHADER_NV.0, + "RAY_TRACING_SHADER_NV", + ), + ( + PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, + "ACCELERATION_STRUCTURE_BUILD_NV", + ), + (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), + (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), + ( + PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59630,6 +59056,813 @@ impl fmt::Display for StructureType { } } } +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RayTracingShaderGroupTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, + "LOW_MEMORY", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationFeatureDisableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", + ), + ( + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESERVED_8 => Some("RESERVED_8"), + Self::RESERVED_4 => Some("RESERVED_4"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TimeDomainEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CopyAccelerationStructureModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), + (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for BufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59673,453 +59906,19 @@ impl fmt::Display for BufferUsageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for CommandPoolCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ImageViewType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationFeatureDisableEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - Self::THREAD_SAFETY => Some("THREAD_SAFETY"), - Self::API_PARAMETERS => Some("API_PARAMETERS"), - Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), - Self::CORE_CHECKS => Some("CORE_CHECKS"), - Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShadingRatePaletteEntryNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), - Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), - Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), - Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), - Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), - Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), - (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), - ( - PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, - "TRANSFORM_FEEDBACK_EXT", - ), - ( - PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ( - PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - PipelineStageFlags::RAY_TRACING_SHADER_NV.0, - "RAY_TRACING_SHADER_NV", - ), - ( - PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, - "ACCELERATION_STRUCTURE_BUILD_NV", - ), - (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), - (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), - ( - PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, - "FRAGMENT_DENSITY_PROCESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BuildAccelerationStructureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, - "ALLOW_UPDATE", - ), - ( - BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, - "ALLOW_COMPACTION", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, - "PREFER_FAST_TRACE", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, - "PREFER_FAST_BUILD", - ), - ( - BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, - "LOW_MEMORY", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - ( - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, - "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", - ), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryOverallocationBehaviorAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::ALLOWED => Some("ALLOWED"), - Self::DISALLOWED => Some("DISALLOWED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -60142,186 +59941,55 @@ impl fmt::Display for PipelineCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CompositeAlphaFlagsKHR { +impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), - (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), - (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassContents { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceGroupPresentModeFlagsKHR { +impl fmt::Display for ResolveModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), - (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), - (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), - ( - DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, - "LOCAL_MULTI_DEVICE", - ), + (ResolveModeFlagsKHR::NONE.0, "NONE"), + (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), + (ResolveModeFlagsKHR::MIN.0, "MIN"), + (ResolveModeFlagsKHR::MAX.0, "MAX"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SamplerYcbcrModelConversion { +impl fmt::Display for FormatFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TRIANGLES => Some("TRIANGLES"), - Self::AABBS => Some("AABBS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", - ), - ]; + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; display_flags(f, KNOWN, self.0) } } @@ -60354,65 +60022,114 @@ impl fmt::Display for ShaderStageFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FormatFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageUsageFlags { +impl fmt::Display for SparseImageFormatFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", ), ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), - (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), - (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for MemoryHeapFlags { +impl fmt::Display for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for BorderColor { +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ObjectEntryUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DisplayPowerStateEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), _ => None, }; if let Some(x) = name { @@ -60422,24 +60139,25 @@ impl fmt::Display for BorderColor { } } } -impl fmt::Display for CommandPoolCreateFlags { +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SharingMode { +impl fmt::Display for SubpassContents { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), _ => None, }; if let Some(x) = name { @@ -60449,58 +60167,342 @@ impl fmt::Display for SharingMode { } } } -impl fmt::Display for DescriptorPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", - ), - ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SamplerCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - ( - SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, - "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ChromaLocation { +impl fmt::Display for SamplerMipmapMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"), + (AccessFlags::RESERVED_31_KHR.0, "RESERVED_31_KHR"), + (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"), + (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"), + ( + AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags::COMMAND_PROCESS_READ_NVX.0, + "COMMAND_PROCESS_READ_NVX", + ), + ( + AccessFlags::COMMAND_PROCESS_WRITE_NVX.0, + "COMMAND_PROCESS_WRITE_NVX", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags::SHADING_RATE_IMAGE_READ_NV.0, + "SHADING_RATE_IMAGE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_READ_NV.0, + "ACCELERATION_STRUCTURE_READ_NV", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_WRITE_NV.0, + "ACCELERATION_STRUCTURE_WRITE_NV", + ), + ( + AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, + "FRAGMENT_DENSITY_MAP_READ_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AccelerationStructureTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for QueueGlobalPriorityEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), _ => None, }; if let Some(x) = name { @@ -60595,26 +60597,3 @@ pub type SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; -#[cfg(test)] -mod tests { - use vk; - #[test] - fn test_ptr_chains() { - let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); - let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); - let chain = vec![ - &variable_pointers as *const _ as usize, - &corner as *const _ as usize, - ]; - let mut device_create_info = vk::DeviceCreateInfo::builder() - .push_next(&mut corner) - .push_next(&mut variable_pointers); - let chain2: Vec = unsafe { - vk::ptr_chain_iter(&mut device_create_info) - .skip(1) - .map(|ptr| ptr as usize) - .collect() - }; - assert_eq!(chain, chain2); - } -} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 4078516..3219ea6 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -85,33 +85,6 @@ named!(cfloat<&str, f32>, terminated!(nom::float_s, char!('f')) ); -pub fn define_test() -> Tokens { - quote! { - #[cfg(test)] - mod tests { - use vk; - #[test] - fn test_ptr_chains() { - let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); - let mut corner = - vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); - let chain = vec![ - &variable_pointers as *const _ as usize, - &corner as *const _ as usize, - ]; - let mut device_create_info = vk::DeviceCreateInfo::builder() - .push_next(&mut corner) - .push_next(&mut variable_pointers); - let chain2: Vec = unsafe { - vk::ptr_chain_iter(&mut device_create_info).skip(1) - .map(|ptr| ptr as usize) - .collect() - }; - assert_eq!(chain, chain2); - } - } - } -} pub fn define_handle_macro() -> Tokens { quote! { #[macro_export] @@ -2222,13 +2195,12 @@ pub fn write_source_code(path: &Path) { let define_handle_macro = define_handle_macro(); let version_macros = vk_version_macros(); let platform_specific_types = platform_specific_types(); - let define_test = define_test(); let source_code = quote! { use std::fmt; use std::os::raw::*; - // Iterates through the pointer chain. Includes the item that is passed into the function. - // Stops at the last `BaseOutStructure` that has a null `p_next` field. - pub(crate) unsafe fn ptr_chain_iter( + /// Iterates through the pointer chain. Includes the item that is passed into the function. + /// Stops at the last `BaseOutStructure` that has a null `p_next` field. + pub unsafe fn ptr_chain_iter( ptr: &mut T, ) -> impl Iterator { use std::ptr::null_mut; @@ -2264,7 +2236,6 @@ pub fn write_source_code(path: &Path) { #feature_extensions_code #const_displays #(#aliases)* - #define_test }; write!(&mut file, "{}", source_code).expect("Unable to write to file"); } From 2d730cdf657ee7b70ce749a200820760bc3e21aa Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sat, 9 Mar 2019 19:52:25 +0100 Subject: [PATCH 19/21] Add ptrchain external test file --- ash/tests/ptrchain.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 ash/tests/ptrchain.rs diff --git a/ash/tests/ptrchain.rs b/ash/tests/ptrchain.rs new file mode 100644 index 0000000..eca4d09 --- /dev/null +++ b/ash/tests/ptrchain.rs @@ -0,0 +1,21 @@ +extern crate ash; +use ash::vk; +#[test] +fn test_ptr_chains() { + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); + let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); + let chain = vec![ + &variable_pointers as *const _ as usize, + &corner as *const _ as usize, + ]; + let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); + let chain2: Vec = unsafe { + vk::ptr_chain_iter(&mut device_create_info) + .skip(1) + .map(|ptr| ptr as usize) + .collect() + }; + assert_eq!(chain, chain2); +} From 7d5d20017b23ac90b23d495513c80adc5a5a7d50 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 10 Mar 2019 09:45:54 +0100 Subject: [PATCH 20/21] Move external tests to lib.rs --- ash/src/lib.rs | 24 + ash/src/vk.rs | 4622 ++++++++++++++++++++--------------------- ash/tests/ptrchain.rs | 21 - generator/src/lib.rs | 2 +- 4 files changed, 2336 insertions(+), 2333 deletions(-) delete mode 100644 ash/tests/ptrchain.rs diff --git a/ash/src/lib.rs b/ash/src/lib.rs index 347cdf6..43581dd 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -31,3 +31,27 @@ impl<'r, T> RawPtr for Option<&'r T> { } } } + +#[cfg(test)] +mod tests { + use super::vk; + #[test] + fn test_ptr_chains() { + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); + let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); + let chain = vec![ + &variable_pointers as *const _ as usize, + &corner as *const _ as usize, + ]; + let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); + let chain2: Vec = unsafe { + vk::ptr_chain_iter(&mut device_create_info) + .skip(1) + .map(|ptr| ptr as usize) + .collect() + }; + assert_eq!(chain, chain2); + } +} diff --git a/ash/src/vk.rs b/ash/src/vk.rs index 859c62f..715d02d 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -2,7 +2,7 @@ use std::fmt; use std::os::raw::*; #[doc = r" Iterates through the pointer chain. Includes the item that is passed into the function."] #[doc = r" Stops at the last `BaseOutStructure` that has a null `p_next` field."] -pub unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { +pub(crate) unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { use std::ptr::null_mut; let ptr: *mut BaseOutStructure = ptr as *mut T as _; (0..).scan(ptr, |p_ptr, _| { @@ -57160,419 +57160,57 @@ fn display_flags( } Ok(()) } -impl fmt::Display for IndexType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UINT16 => Some("UINT16"), - Self::UINT32 => Some("UINT32"), - Self::NONE_NV => Some("NONE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), - Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineBindPoint { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GRAPHICS => Some("GRAPHICS"), - Self::COMPUTE => Some("COMPUTE"), - Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportObjectTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNKNOWN => Some("UNKNOWN"), - Self::INSTANCE => Some("INSTANCE"), - Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), - Self::DEVICE => Some("DEVICE"), - Self::QUEUE => Some("QUEUE"), - Self::SEMAPHORE => Some("SEMAPHORE"), - Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), - Self::FENCE => Some("FENCE"), - Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), - Self::BUFFER => Some("BUFFER"), - Self::IMAGE => Some("IMAGE"), - Self::EVENT => Some("EVENT"), - Self::QUERY_POOL => Some("QUERY_POOL"), - Self::BUFFER_VIEW => Some("BUFFER_VIEW"), - Self::IMAGE_VIEW => Some("IMAGE_VIEW"), - Self::SHADER_MODULE => Some("SHADER_MODULE"), - Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), - Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), - Self::RENDER_PASS => Some("RENDER_PASS"), - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), - Self::SAMPLER => Some("SAMPLER"), - Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::FRAMEBUFFER => Some("FRAMEBUFFER"), - Self::COMMAND_POOL => Some("COMMAND_POOL"), - Self::SURFACE_KHR => Some("SURFACE_KHR"), - Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), - Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), - Self::DISPLAY_KHR => Some("DISPLAY_KHR"), - Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), - Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), - Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), - Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), - Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), - Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ComponentSwizzle { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IDENTITY => Some("IDENTITY"), - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::R => Some("R"), - Self::G => Some("G"), - Self::B => Some("B"), - Self::A => Some("A"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ObjectEntryTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::PIPELINE => Some("PIPELINE"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorPoolCreateFlags { +impl fmt::Display for ShaderStageFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), ( - DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, - "FREE_DESCRIPTOR_SET", + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", ), ( - DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, - "UPDATE_AFTER_BIND_EXT", + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), + (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), + (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), + (ShaderStageFlags::MISS_NV.0, "MISS_NV"), + (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), + (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), + (ShaderStageFlags::TASK_NV.0, "TASK_NV"), + (ShaderStageFlags::MESH_NV.0, "MESH_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationFeatureEnableEXT { +impl fmt::Display for Filter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::GPU_ASSISTED => Some("GPU_ASSISTED"), - Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryInstanceFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, - "TRIANGLE_CULL_DISABLE", - ), - ( - GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, - "TRIANGLE_FRONT_COUNTERCLOCKWISE", - ), - (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), - ( - GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, - "FORCE_NO_OPAQUE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferResetFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - CommandBufferResetFlags::RELEASE_RESOURCES.0, - "RELEASE_RESOURCES", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for StencilOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::KEEP => Some("KEEP"), - Self::ZERO => Some("ZERO"), - Self::REPLACE => Some("REPLACE"), - Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), - Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), - Self::INVERT => Some("INVERT"), - Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), - Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TRIANGLES => Some("TRIANGLES"), - Self::AABBS => Some("AABBS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrModelConversion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::RGB_IDENTITY => Some("RGB_IDENTITY"), - Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), - Self::YCBCR_709 => Some("YCBCR_709"), - Self::YCBCR_601 => Some("YCBCR_601"), - Self::YCBCR_2020 => Some("YCBCR_2020"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DynamicState { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIEWPORT => Some("VIEWPORT"), - Self::SCISSOR => Some("SCISSOR"), - Self::LINE_WIDTH => Some("LINE_WIDTH"), - Self::DEPTH_BIAS => Some("DEPTH_BIAS"), - Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), - Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), - Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), - Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), - Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), - Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), - Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), - Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), - Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), - Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), - Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PhysicalDeviceType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OTHER => Some("OTHER"), - Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), - Self::DISCRETE_GPU => Some("DISCRETE_GPU"), - Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), - Self::CPU => Some("CPU"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BorderColor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), - Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), - Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), - Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), - Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), - Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BlendOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ADD => Some("ADD"), - Self::SUBTRACT => Some("SUBTRACT"), - Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - Self::ZERO_EXT => Some("ZERO_EXT"), - Self::SRC_EXT => Some("SRC_EXT"), - Self::DST_EXT => Some("DST_EXT"), - Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), - Self::DST_OVER_EXT => Some("DST_OVER_EXT"), - Self::SRC_IN_EXT => Some("SRC_IN_EXT"), - Self::DST_IN_EXT => Some("DST_IN_EXT"), - Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), - Self::DST_OUT_EXT => Some("DST_OUT_EXT"), - Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), - Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), - Self::XOR_EXT => Some("XOR_EXT"), - Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), - Self::SCREEN_EXT => Some("SCREEN_EXT"), - Self::OVERLAY_EXT => Some("OVERLAY_EXT"), - Self::DARKEN_EXT => Some("DARKEN_EXT"), - Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), - Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), - Self::COLORBURN_EXT => Some("COLORBURN_EXT"), - Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), - Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), - Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), - Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), - Self::INVERT_EXT => Some("INVERT_EXT"), - Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), - Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), - Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), - Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), - Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), - Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), - Self::HARDMIX_EXT => Some("HARDMIX_EXT"), - Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), - Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), - Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), - Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), - Self::PLUS_EXT => Some("PLUS_EXT"), - Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), - Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), - Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), - Self::MINUS_EXT => Some("MINUS_EXT"), - Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), - Self::CONTRAST_EXT => Some("CONTRAST_EXT"), - Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), - Self::RED_EXT => Some("RED_EXT"), - Self::GREEN_EXT => Some("GREEN_EXT"), - Self::BLUE_EXT => Some("BLUE_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageViewCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DiscardRectangleModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INCLUSIVE => Some("INCLUSIVE"), - Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_IMG => Some("CUBIC_IMG"), _ => None, }; if let Some(x) = name { @@ -57588,12 +57226,12 @@ impl fmt::Display for FenceImportFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ConservativeRasterizationModeEXT { +impl fmt::Display for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::DISABLED => Some("DISABLED"), - Self::OVERESTIMATE => Some("OVERESTIMATE"), - Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), _ => None, }; if let Some(x) = name { @@ -57603,825 +57241,25 @@ impl fmt::Display for ConservativeRasterizationModeEXT { } } } -impl fmt::Display for ExternalFenceHandleTypeFlags { +impl fmt::Display for ExternalMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", ), ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SwapchainCreateFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, - "SPLIT_INSTANCE_BIND_REGIONS", - ), - (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), - (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FrontFace { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), - Self::CLOCKWISE => Some("CLOCKWISE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - (ImageUsageFlags::SAMPLED.0, "SAMPLED"), - (ImageUsageFlags::STORAGE.0, "STORAGE"), - (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), - ( - ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, - "DEPTH_STENCIL_ATTACHMENT", - ), - ( - ImageUsageFlags::TRANSIENT_ATTACHMENT.0, - "TRANSIENT_ATTACHMENT", - ), - (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), - (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), - (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), - (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), - ( - ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, - "FRAGMENT_DENSITY_MAP_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for LogicOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLEAR => Some("CLEAR"), - Self::AND => Some("AND"), - Self::AND_REVERSE => Some("AND_REVERSE"), - Self::COPY => Some("COPY"), - Self::AND_INVERTED => Some("AND_INVERTED"), - Self::NO_OP => Some("NO_OP"), - Self::XOR => Some("XOR"), - Self::OR => Some("OR"), - Self::NOR => Some("NOR"), - Self::EQUIVALENT => Some("EQUIVALENT"), - Self::INVERT => Some("INVERT"), - Self::OR_REVERSE => Some("OR_REVERSE"), - Self::COPY_INVERTED => Some("COPY_INVERTED"), - Self::OR_INVERTED => Some("OR_INVERTED"), - Self::NAND => Some("NAND"), - Self::SET => Some("SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DependencyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DependencyFlags::BY_REGION.0, "BY_REGION"), - (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), - (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCacheHeaderVersion { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), - ( - SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, - "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoverageModulationModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NONE => Some("NONE"), - Self::RGB => Some("RGB"), - Self::ALPHA => Some("ALPHA"), - Self::RGBA => Some("RGBA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShadingRatePaletteEntryNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), - Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), - Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), - Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), - Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), - Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), - Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), - Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), - Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OBJECT => Some("OBJECT"), - Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), - Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for QueryPipelineStatisticFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, - "INPUT_ASSEMBLY_VERTICES", - ), - ( - QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, - "INPUT_ASSEMBLY_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, - "VERTEX_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, - "GEOMETRY_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, - "GEOMETRY_SHADER_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, - "CLIPPING_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, - "CLIPPING_PRIMITIVES", - ), - ( - QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, - "FRAGMENT_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, - "TESSELLATION_CONTROL_SHADER_PATCHES", - ), - ( - QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, - "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", - ), - ( - QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, - "COMPUTE_SHADER_INVOCATIONS", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SurfaceCounterFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for RasterizationOrderAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STRICT => Some("STRICT"), - Self::RELAXED => Some("RELAXED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for Format { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), - Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), - Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), - Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), - Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), - Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), - Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), - Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), - Self::R8_UNORM => Some("R8_UNORM"), - Self::R8_SNORM => Some("R8_SNORM"), - Self::R8_USCALED => Some("R8_USCALED"), - Self::R8_SSCALED => Some("R8_SSCALED"), - Self::R8_UINT => Some("R8_UINT"), - Self::R8_SINT => Some("R8_SINT"), - Self::R8_SRGB => Some("R8_SRGB"), - Self::R8G8_UNORM => Some("R8G8_UNORM"), - Self::R8G8_SNORM => Some("R8G8_SNORM"), - Self::R8G8_USCALED => Some("R8G8_USCALED"), - Self::R8G8_SSCALED => Some("R8G8_SSCALED"), - Self::R8G8_UINT => Some("R8G8_UINT"), - Self::R8G8_SINT => Some("R8G8_SINT"), - Self::R8G8_SRGB => Some("R8G8_SRGB"), - Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), - Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), - Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), - Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), - Self::R8G8B8_UINT => Some("R8G8B8_UINT"), - Self::R8G8B8_SINT => Some("R8G8B8_SINT"), - Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), - Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), - Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), - Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), - Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), - Self::B8G8R8_UINT => Some("B8G8R8_UINT"), - Self::B8G8R8_SINT => Some("B8G8R8_SINT"), - Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), - Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), - Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), - Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), - Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), - Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), - Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), - Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), - Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), - Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), - Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), - Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), - Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), - Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), - Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), - Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), - Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), - Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), - Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), - Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), - Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), - Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), - Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), - Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), - Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), - Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), - Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), - Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), - Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), - Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), - Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), - Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), - Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), - Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), - Self::R16_UNORM => Some("R16_UNORM"), - Self::R16_SNORM => Some("R16_SNORM"), - Self::R16_USCALED => Some("R16_USCALED"), - Self::R16_SSCALED => Some("R16_SSCALED"), - Self::R16_UINT => Some("R16_UINT"), - Self::R16_SINT => Some("R16_SINT"), - Self::R16_SFLOAT => Some("R16_SFLOAT"), - Self::R16G16_UNORM => Some("R16G16_UNORM"), - Self::R16G16_SNORM => Some("R16G16_SNORM"), - Self::R16G16_USCALED => Some("R16G16_USCALED"), - Self::R16G16_SSCALED => Some("R16G16_SSCALED"), - Self::R16G16_UINT => Some("R16G16_UINT"), - Self::R16G16_SINT => Some("R16G16_SINT"), - Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), - Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), - Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), - Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), - Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), - Self::R16G16B16_UINT => Some("R16G16B16_UINT"), - Self::R16G16B16_SINT => Some("R16G16B16_SINT"), - Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), - Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), - Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), - Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), - Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), - Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), - Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), - Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), - Self::R32_UINT => Some("R32_UINT"), - Self::R32_SINT => Some("R32_SINT"), - Self::R32_SFLOAT => Some("R32_SFLOAT"), - Self::R32G32_UINT => Some("R32G32_UINT"), - Self::R32G32_SINT => Some("R32G32_SINT"), - Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), - Self::R32G32B32_UINT => Some("R32G32B32_UINT"), - Self::R32G32B32_SINT => Some("R32G32B32_SINT"), - Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), - Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), - Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), - Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), - Self::R64_UINT => Some("R64_UINT"), - Self::R64_SINT => Some("R64_SINT"), - Self::R64_SFLOAT => Some("R64_SFLOAT"), - Self::R64G64_UINT => Some("R64G64_UINT"), - Self::R64G64_SINT => Some("R64G64_SINT"), - Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), - Self::R64G64B64_UINT => Some("R64G64B64_UINT"), - Self::R64G64B64_SINT => Some("R64G64B64_SINT"), - Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), - Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), - Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), - Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), - Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), - Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), - Self::D16_UNORM => Some("D16_UNORM"), - Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), - Self::D32_SFLOAT => Some("D32_SFLOAT"), - Self::S8_UINT => Some("S8_UINT"), - Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), - Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), - Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), - Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), - Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), - Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), - Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), - Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), - Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), - Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), - Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), - Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), - Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), - Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), - Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), - Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), - Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), - Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), - Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), - Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), - Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), - Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), - Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), - Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), - Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), - Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), - Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), - Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), - Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), - Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), - Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), - Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), - Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), - Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), - Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), - Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), - Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), - Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), - Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), - Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), - Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), - Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), - Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), - Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), - Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), - Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), - Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), - Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), - Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), - Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), - Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), - Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), - Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), - Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), - Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), - Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), - Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), - Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), - Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), - Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), - Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), - Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), - Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), - Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), - Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), - Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), - Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), - Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), - Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), - Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), - Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), - Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { - Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") - } - Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { - Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { - Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") - } - Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { - Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") - } - Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), - Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), - Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), - Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { - Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") - } - Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { - Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { - Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") - } - Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { - Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") - } - Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), - Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), - Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), - Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), - Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), - Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), - Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for CoarseSampleOrderTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::CUSTOM => Some("CUSTOM"), - Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), - Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for MemoryPropertyFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), - (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), - (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), - (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), - (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ValidationCheckEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL => Some("ALL"), - Self::SHADERS => Some("SHADERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerReductionModeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), - Self::MIN => Some("MIN"), - Self::MAX => Some("MAX"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerYcbcrRange { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ITU_FULL => Some("ITU_FULL"), - Self::ITU_NARROW => Some("ITU_NARROW"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DriverIdKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), - Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), - Self::MESA_RADV => Some("MESA_RADV"), - Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), - Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), - Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), - Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), - Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), - Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), - Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentLoadOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::LOAD => Some("LOAD"), - Self::CLEAR => Some("CLEAR"), - Self::DONT_CARE => Some("DONT_CARE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerAddressMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::REPEAT => Some("REPEAT"), - Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), - Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), - Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VendorId { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VIV => Some("VIV"), - Self::VSI => Some("VSI"), - Self::KAZAN => Some("KAZAN"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PresentModeKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::IMMEDIATE => Some("IMMEDIATE"), - Self::MAILBOX => Some("MAILBOX"), - Self::FIFO => Some("FIFO"), - Self::FIFO_RELAXED => Some("FIFO_RELAXED"), - Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), - Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PipelineStageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), - (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), - (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), - (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), - ( - PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, - "TESSELLATION_CONTROL_SHADER", - ), - ( - PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, - "TESSELLATION_EVALUATION_SHADER", - ), - (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), - (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), - ( - PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, - "EARLY_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::LATE_FRAGMENT_TESTS.0, - "LATE_FRAGMENT_TESTS", - ), - ( - PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, - "COLOR_ATTACHMENT_OUTPUT", - ), - (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), - (PipelineStageFlags::TRANSFER.0, "TRANSFER"), - (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), - (PipelineStageFlags::HOST.0, "HOST"), - (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), - (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), - (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), - ( - PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, - "TRANSFORM_FEEDBACK_EXT", - ), - ( - PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - ( - PipelineStageFlags::COMMAND_PROCESS_NVX.0, - "COMMAND_PROCESS_NVX", - ), - ( - PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, - "SHADING_RATE_IMAGE_NV", - ), - ( - PipelineStageFlags::RAY_TRACING_SHADER_NV.0, - "RAY_TRACING_SHADER_NV", - ), - ( - PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, - "ACCELERATION_STRUCTURE_BUILD_NV", - ), - (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), - (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), - ( - PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, - "FRAGMENT_DENSITY_PROCESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PointClippingBehavior { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), - Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SharingMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXCLUSIVE => Some("EXCLUSIVE"), - Self::CONCURRENT => Some("CONCURRENT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for AttachmentDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for StructureType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -59056,101 +57894,385 @@ impl fmt::Display for StructureType { } } } -impl fmt::Display for PolygonMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::FILL => Some("FILL"), - Self::LINE => Some("LINE"), - Self::POINT => Some("POINT"), - Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for RayTracingShaderGroupTypeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::GENERAL => Some("GENERAL"), - Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), - Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ShaderInfoTypeAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::STATISTICS => Some("STATISTICS"), - Self::BINARY => Some("BINARY"), - Self::DISASSEMBLY => Some("DISASSEMBLY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlagsNV { +impl fmt::Display for SwapchainCreateFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", ), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + (ImageUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (ImageUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + (ImageUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (ImageUsageFlags::RESERVED_10_KHR.0, "RESERVED_10_KHR"), + (ImageUsageFlags::RESERVED_11_KHR.0, "RESERVED_11_KHR"), + (ImageUsageFlags::RESERVED_12_KHR.0, "RESERVED_12_KHR"), + ( + ImageUsageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", ), ( - ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for RenderPassCreateFlags { +impl fmt::Display for ConditionalRenderingFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = - &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SparseMemoryBindFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DeviceQueueCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryControlFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for AttachmentStoreOp { +impl fmt::Display for SamplerAddressMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::STORE => Some("STORE"), - Self::DONT_CARE => Some("DONT_CARE"), + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), _ => None, }; if let Some(x) = name { @@ -59160,120 +58282,11 @@ impl fmt::Display for AttachmentStoreOp { } } } -impl fmt::Display for BlendFactor { +impl fmt::Display for AccelerationStructureTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::ZERO => Some("ZERO"), - Self::ONE => Some("ONE"), - Self::SRC_COLOR => Some("SRC_COLOR"), - Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), - Self::DST_COLOR => Some("DST_COLOR"), - Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), - Self::SRC_ALPHA => Some("SRC_ALPHA"), - Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), - Self::DST_ALPHA => Some("DST_ALPHA"), - Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), - Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), - Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), - Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), - Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), - Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), - Self::SRC1_COLOR => Some("SRC1_COLOR"), - Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), - Self::SRC1_ALPHA => Some("SRC1_ALPHA"), - Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ChromaLocation { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COSITED_EVEN => Some("COSITED_EVEN"), - Self::MIDPOINT => Some("MIDPOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for GeometryFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), - ( - GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, - "NO_DUPLICATE_ANY_HIT_INVOCATION", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BuildAccelerationStructureFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, - "ALLOW_UPDATE", - ), - ( - BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, - "ALLOW_COMPACTION", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, - "PREFER_FAST_TRACE", - ), - ( - BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, - "PREFER_FAST_BUILD", - ), - ( - BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, - "LOW_MEMORY", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SAMPLER => Some("SAMPLER"), - Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), - Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), - Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), - Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), - Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), - Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), - Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), - Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), - Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), - Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), - Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), - Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for VertexInputRate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::VERTEX => Some("VERTEX"), - Self::INSTANCE => Some("INSTANCE"), + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), _ => None, }; if let Some(x) = name { @@ -59302,645 +58315,6 @@ impl fmt::Display for ValidationFeatureDisableEXT { } } } -impl fmt::Display for ViewportCoordinateSwizzleNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::POSITIVE_X => Some("POSITIVE_X"), - Self::NEGATIVE_X => Some("NEGATIVE_X"), - Self::POSITIVE_Y => Some("POSITIVE_Y"), - Self::NEGATIVE_Y => Some("NEGATIVE_Y"), - Self::POSITIVE_Z => Some("POSITIVE_Z"), - Self::NEGATIVE_Z => Some("NEGATIVE_Z"), - Self::POSITIVE_W => Some("POSITIVE_W"), - Self::NEGATIVE_W => Some("NEGATIVE_W"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DeviceEventTypeEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TessellationDomainOrigin { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UPPER_LEFT => Some("UPPER_LEFT"), - Self::LOWER_LEFT => Some("LOWER_LEFT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageTiling { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OPTIMAL => Some("OPTIMAL"), - Self::LINEAR => Some("LINEAR"), - Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY.0, - "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_EXPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_EXPORTABLE", - ), - ( - ExternalMemoryFeatureFlags::EXTERNAL_MEMORY_FEATURE_IMPORTABLE.0, - "EXTERNAL_MEMORY_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OCCLUSION => Some("OCCLUSION"), - Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), - Self::TIMESTAMP => Some("TIMESTAMP"), - Self::RESERVED_8 => Some("RESERVED_8"), - Self::RESERVED_4 => Some("RESERVED_4"), - Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), - Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { - Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for BufferCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), - (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), - ( - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, - "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", - ), - (BufferCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageLayout { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNDEFINED => Some("UNDEFINED"), - Self::GENERAL => Some("GENERAL"), - Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), - Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), - Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), - Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), - Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), - Self::PREINITIALIZED => Some("PREINITIALIZED"), - Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), - Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), - Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), - Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), - Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { - Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") - } - Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { - Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") - } - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for TimeDomainEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEVICE => Some("DEVICE"), - Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), - Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), - Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ColorSpaceKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), - Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), - Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), - Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), - Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), - Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), - Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), - Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), - Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), - Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), - Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), - Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), - Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), - Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), - Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DebugReportFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), - (DebugReportFlagsEXT::WARNING.0, "WARNING"), - ( - DebugReportFlagsEXT::PERFORMANCE_WARNING.0, - "PERFORMANCE_WARNING", - ), - (DebugReportFlagsEXT::ERROR.0, "ERROR"), - (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryHeapFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), - (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CopyAccelerationStructureModeNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::CLONE => Some("CLONE"), - Self::COMPACT => Some("COMPACT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DescriptorUpdateTemplateType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for InternalAllocationType { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::EXECUTABLE => Some("EXECUTABLE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for PeerMemoryFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), - (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), - (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), - (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BlendOverlapEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::UNCORRELATED => Some("UNCORRELATED"), - Self::DISJOINT => Some("DISJOINT"), - Self::CONJOINT => Some("CONJOINT"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SemaphoreImportFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for FenceCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), - (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), - (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), - (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryAllocateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorSetLayoutCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, - "PUSH_DESCRIPTOR_KHR", - ), - ( - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, - "UPDATE_AFTER_BIND_POOL_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for MemoryOverallocationBehaviorAMD { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::DEFAULT => Some("DEFAULT"), - Self::ALLOWED => Some("ALLOWED"), - Self::DISALLOWED => Some("DISALLOWED"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, - "UNORDERED_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, - "SPARSE_SEQUENCES", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, - "EMPTY_EXECUTIONS", - ), - ( - IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, - "INDEXED_SEQUENCES", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CullModeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CullModeFlags::NONE.0, "NONE"), - (CullModeFlags::FRONT.0, "FRONT"), - (CullModeFlags::BACK.0, "BACK"), - (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ExternalSemaphoreHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", - ), - ( - ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, - "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DescriptorBindingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, - "UPDATE_AFTER_BIND", - ), - ( - DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, - "UPDATE_UNUSED_WHILE_PENDING", - ), - ( - DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, - "PARTIALLY_BOUND", - ), - ( - DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, - "VARIABLE_DESCRIPTOR_COUNT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueueFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueueFlags::GRAPHICS.0, "GRAPHICS"), - (QueueFlags::COMPUTE.0, "COMPUTE"), - (QueueFlags::TRANSFER.0, "TRANSFER"), - (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), - (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), - (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), - (QueueFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for IndirectCommandsTokenTypeNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PIPELINE => Some("PIPELINE"), - Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), - Self::INDEX_BUFFER => Some("INDEX_BUFFER"), - Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), - Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), - Self::DRAW_INDEXED => Some("DRAW_INDEXED"), - Self::DRAW => Some("DRAW"), - Self::DISPATCH => Some("DISPATCH"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalSemaphoreFeatureFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", - ), - ( - ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, - "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CompareOp { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEVER => Some("NEVER"), - Self::LESS => Some("LESS"), - Self::EQUAL => Some("EQUAL"), - Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), - Self::GREATER => Some("GREATER"), - Self::NOT_EQUAL => Some("NOT_EQUAL"), - Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), - Self::ALWAYS => Some("ALWAYS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ImageAspectFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ImageAspectFlags::COLOR.0, "COLOR"), - (ImageAspectFlags::DEPTH.0, "DEPTH"), - (ImageAspectFlags::STENCIL.0, "STENCIL"), - (ImageAspectFlags::METADATA.0, "METADATA"), - (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), - (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), - (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), - (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), - (ImageAspectFlags::PLANE_0.0, "PLANE_0"), - (ImageAspectFlags::PLANE_1.0, "PLANE_1"), - (ImageAspectFlags::PLANE_2.0, "PLANE_2"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandBufferLevel { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::PRIMARY => Some("PRIMARY"), - Self::SECONDARY => Some("SECONDARY"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalMemoryHandleTypeFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SystemAllocationScope { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::COMMAND => Some("COMMAND"), - Self::OBJECT => Some("OBJECT"), - Self::CACHE => Some("CACHE"), - Self::DEVICE => Some("DEVICE"), - Self::INSTANCE => Some("INSTANCE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for StencilFaceFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (StencilFaceFlags::FRONT.0, "FRONT"), - (StencilFaceFlags::BACK.0, "BACK"), - ( - StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, - "STENCIL_FRONT_AND_BACK", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for BufferUsageFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), - (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), - ( - BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, - "UNIFORM_TEXEL_BUFFER", - ), - ( - BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, - "STORAGE_TEXEL_BUFFER", - ), - (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), - (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), - (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), - (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), - (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), - (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), - (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), - (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), - (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_BUFFER_EXT", - ), - ( - BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", - ), - ( - BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, - "CONDITIONAL_RENDERING_EXT", - ), - (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), - ( - BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, - "SHADER_DEVICE_ADDRESS_EXT", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for CommandPoolCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), - ( - CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, - "RESET_COMMAND_BUFFER", - ), - (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for PipelineCreateFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - PipelineCreateFlags::DISABLE_OPTIMIZATION.0, - "DISABLE_OPTIMIZATION", - ), - ( - PipelineCreateFlags::ALLOW_DERIVATIVES.0, - "ALLOW_DERIVATIVES", - ), - (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), - ( - PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, - "VIEW_INDEX_FROM_DEVICE_INDEX", - ), - (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), - ]; - display_flags(f, KNOWN, self.0) - } -} impl fmt::Display for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -59975,66 +58349,40 @@ impl fmt::Display for ImageCreateFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ResolveModeFlagsKHR { +impl fmt::Display for DebugReportFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ResolveModeFlagsKHR::NONE.0, "NONE"), - (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), - (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), - (ResolveModeFlagsKHR::MIN.0, "MIN"), - (ResolveModeFlagsKHR::MAX.0, "MAX"), + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for FormatFeatureFlags { +impl fmt::Display for TimeDomainEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; - display_flags(f, KNOWN, self.0) + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } } } -impl fmt::Display for ShaderStageFlags { +impl fmt::Display for SparseMemoryBindFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ShaderStageFlags::VERTEX.0, "VERTEX"), - ( - ShaderStageFlags::TESSELLATION_CONTROL.0, - "TESSELLATION_CONTROL", - ), - ( - ShaderStageFlags::TESSELLATION_EVALUATION.0, - "TESSELLATION_EVALUATION", - ), - (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), - (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), - (ShaderStageFlags::COMPUTE.0, "COMPUTE"), - (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), - (ShaderStageFlags::ALL.0, "ALL"), - (ShaderStageFlags::RAYGEN_NV.0, "RAYGEN_NV"), - (ShaderStageFlags::ANY_HIT_NV.0, "ANY_HIT_NV"), - (ShaderStageFlags::CLOSEST_HIT_NV.0, "CLOSEST_HIT_NV"), - (ShaderStageFlags::MISS_NV.0, "MISS_NV"), - (ShaderStageFlags::INTERSECTION_NV.0, "INTERSECTION_NV"), - (ShaderStageFlags::CALLABLE_NV.0, "CALLABLE_NV"), - (ShaderStageFlags::TASK_NV.0, "TASK_NV"), - (ShaderStageFlags::MESH_NV.0, "MESH_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SparseImageFormatFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), - ( - SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, - "ALIGNED_MIP_SIZE", - ), - ( - SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, - "NONSTANDARD_BLOCK_SIZE", - ), - ]; + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; display_flags(f, KNOWN, self.0) } } @@ -60047,32 +58395,123 @@ impl fmt::Display for CommandPoolResetFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for CommandBufferUsageFlags { +impl fmt::Display for BufferCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), ( - CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, - "ONE_TIME_SUBMIT", - ), - ( - CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, - "RENDER_PASS_CONTINUE", - ), - ( - CommandBufferUsageFlags::SIMULTANEOUS_USE.0, - "SIMULTANEOUS_USE", + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY_EXT.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY_EXT", ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ColorComponentFlags { +impl fmt::Display for RayTracingShaderGroupTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalSemaphoreHandleTypeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (ColorComponentFlags::R.0, "R"), - (ColorComponentFlags::G.0, "G"), - (ColorComponentFlags::B.0, "B"), - (ColorComponentFlags::A.0, "A"), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", + ), + ( + ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD", + ), ]; display_flags(f, KNOWN, self.0) } @@ -60088,97 +58527,29 @@ impl fmt::Display for CompositeAlphaFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubgroupFeatureFlags { +impl fmt::Display for ExternalSemaphoreFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SubgroupFeatureFlags::BASIC.0, "BASIC"), - (SubgroupFeatureFlags::VOTE.0, "VOTE"), - (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), - (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), - (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), - (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), - (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), - (SubgroupFeatureFlags::QUAD.0, "QUAD"), - (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for QueryResultFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (QueryResultFlags::TYPE_64.0, "TYPE_64"), - (QueryResultFlags::WAIT.0, "WAIT"), - (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), - (QueryResultFlags::PARTIAL.0, "PARTIAL"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ObjectEntryUsageFlagsNVX { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), - (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DisplayPowerStateEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::OFF => Some("OFF"), - Self::SUSPEND => Some("SUSPEND"), - Self::ON => Some("ON"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for DisplayPlaneAlphaFlagsKHR { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), - (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), - (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), ( - DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, - "PER_PIXEL_PREMULTIPLIED", + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE", + ), + ( + ExternalSemaphoreFeatureFlags::EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE.0, + "EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE", ), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for SubpassContents { +impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::INLINE => Some("INLINE"), - Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for SamplerMipmapMode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ]; + display_flags(f, KNOWN, self.0) } } impl fmt::Display for AccessFlags { @@ -60274,11 +58645,11 @@ impl fmt::Display for AccessFlags { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for AccelerationStructureTypeNV { +impl fmt::Display for ValidationFeatureEnableEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TOP_LEVEL => Some("TOP_LEVEL"), - Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), _ => None, }; if let Some(x) = name { @@ -60288,22 +58659,19 @@ impl fmt::Display for AccelerationStructureTypeNV { } } } -impl fmt::Display for ConditionalRenderingFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for ImageViewType { +impl fmt::Display for DriverIdKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::TYPE_1D => Some("TYPE_1D"), - Self::TYPE_2D => Some("TYPE_2D"), - Self::TYPE_3D => Some("TYPE_3D"), - Self::CUBE => Some("CUBE"), - Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), - Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), - Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_PASTEL => Some("GOOGLE_PASTEL"), _ => None, }; if let Some(x) = name { @@ -60313,20 +58681,177 @@ impl fmt::Display for ImageViewType { } } } -impl fmt::Display for SampleCountFlags { +impl fmt::Display for PipelineCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - (SampleCountFlags::TYPE_1.0, "TYPE_1"), - (SampleCountFlags::TYPE_2.0, "TYPE_2"), - (SampleCountFlags::TYPE_4.0, "TYPE_4"), - (SampleCountFlags::TYPE_8.0, "TYPE_8"), - (SampleCountFlags::TYPE_16.0, "TYPE_16"), - (SampleCountFlags::TYPE_32.0, "TYPE_32"), - (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), ]; display_flags(f, KNOWN, self.0) } } +impl fmt::Display for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV.0, + "EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_EXPORTABLE_NV", + ), + ( + ExternalMemoryFeatureFlagsNV::EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV.0, + "EXTERNAL_MEMORY_FEATURE_IMPORTABLE_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlagsEXT::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlagsEXT::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + ( + DescriptorBindingFlagsEXT::PARTIALLY_BOUND.0, + "PARTIALLY_BOUND", + ), + ( + DescriptorBindingFlagsEXT::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -60341,97 +58866,15 @@ impl fmt::Display for DeviceGroupPresentModeFlagsKHR { display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ValidationCacheHeaderVersionEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::ONE => Some("ONE"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} -impl fmt::Display for ExternalFenceFeatureFlags { +impl fmt::Display for ObjectEntryUsageFlagsNVX { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_EXPORTABLE", - ), - ( - ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, - "EXTERNAL_FENCE_FEATURE_IMPORTABLE", - ), + (ObjectEntryUsageFlagsNVX::GRAPHICS.0, "GRAPHICS"), + (ObjectEntryUsageFlagsNVX::COMPUTE.0, "COMPUTE"), ]; display_flags(f, KNOWN, self.0) } } -impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", - ), - ( - ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, - "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for DebugUtilsMessageTypeFlagsEXT { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), - (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), - (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for SubpassDescriptionFlags { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[ - ( - SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, - "PER_VIEW_ATTRIBUTES_NVX", - ), - ( - SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, - "PER_VIEW_POSITION_X_ONLY_NVX", - ), - ]; - display_flags(f, KNOWN, self.0) - } -} -impl fmt::Display for Filter { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let name = match *self { - Self::NEAREST => Some("NEAREST"), - Self::LINEAR => Some("LINEAR"), - Self::CUBIC_IMG => Some("CUBIC_IMG"), - _ => None, - }; - if let Some(x) = name { - f.write_str(x) - } else { - write!(f, "{}", self.0) - } - } -} impl fmt::Display for DisplayEventTypeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -60445,20 +58888,28 @@ impl fmt::Display for DisplayEventTypeEXT { } } } -impl fmt::Display for PrimitiveTopology { +impl fmt::Display for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ViewportCoordinateSwizzleNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { - Self::POINT_LIST => Some("POINT_LIST"), - Self::LINE_LIST => Some("LINE_LIST"), - Self::LINE_STRIP => Some("LINE_STRIP"), - Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), - Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), - Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), - Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), - Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), - Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), - Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), - Self::PATCH_LIST => Some("PATCH_LIST"), + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), _ => None, }; if let Some(x) = name { @@ -60468,6 +58919,441 @@ impl fmt::Display for PrimitiveTopology { } } } +impl fmt::Display for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + (PipelineStageFlags::RESERVED_27_KHR.0, "RESERVED_27_KHR"), + (PipelineStageFlags::RESERVED_26_KHR.0, "RESERVED_26_KHR"), + ( + PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags::COMMAND_PROCESS_NVX.0, + "COMMAND_PROCESS_NVX", + ), + ( + PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, + "SHADING_RATE_IMAGE_NV", + ), + ( + PipelineStageFlags::RAY_TRACING_SHADER_NV.0, + "RAY_TRACING_SHADER_NV", + ), + ( + PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_NV.0, + "ACCELERATION_STRUCTURE_BUILD_NV", + ), + (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"), + (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"), + ( + PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for GeometryFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsNV::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsNV::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BuildAccelerationStructureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsNV::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsNV::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsNV::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsNV::LOW_MEMORY.0, + "LOW_MEMORY", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndirectCommandsLayoutUsageFlagsNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNVX::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::SPARSE_SEQUENCES.0, + "SPARSE_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::EMPTY_EXECUTIONS.0, + "EMPTY_EXECUTIONS", + ), + ( + IndirectCommandsLayoutUsageFlagsNVX::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerReductionModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ShadingRatePaletteEntryNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK")]; + display_flags(f, KNOWN, self.0) + } +} impl fmt::Display for SurfaceTransformFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -60496,6 +59382,553 @@ impl fmt::Display for SurfaceTransformFlagsKHR { display_flags(f, KNOWN, self.0) } } +impl fmt::Display for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_ANDROID" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION" ) , ( ExternalMemoryHandleTypeFlags :: EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY . 0 , "EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL_EXT.0, + "UPDATE_AFTER_BIND_POOL_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + (BufferUsageFlags::RESERVED_15_KHR.0, "RESERVED_15_KHR"), + (BufferUsageFlags::RESERVED_16_KHR.0, "RESERVED_16_KHR"), + (BufferUsageFlags::RESERVED_13_KHR.0, "RESERVED_13_KHR"), + (BufferUsageFlags::RESERVED_14_KHR.0, "RESERVED_14_KHR"), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RAY_TRACING_NV.0, "RAY_TRACING_NV"), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS_EXT.0, + "SHADER_DEVICE_ADDRESS_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DCI_P3_LINEAR_EXT => Some("DCI_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX_EXT . 0 , "SAMPLED_IMAGE_FILTER_MINMAX_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) ] ; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ResolveModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ResolveModeFlagsKHR::NONE.0, "NONE"), + (ResolveModeFlagsKHR::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlagsKHR::AVERAGE.0, "AVERAGE"), + (ResolveModeFlagsKHR::MIN.0, "MIN"), + (ResolveModeFlagsKHR::MAX.0, "MAX"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::SHADING_RATE_OPTIMAL_NV => Some("SHADING_RATE_OPTIMAL_NV"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_NV => Some("NONE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ObjectEntryTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PIPELINE => Some("PIPELINE"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for IndirectCommandsTokenTypeNVX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DISPATCH => Some("DISPATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} impl fmt::Display for QueueGlobalPriorityEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -60512,6 +59945,573 @@ impl fmt::Display for QueueGlobalPriorityEXT { } } } +impl fmt::Display for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + ( + StencilFaceFlags::STENCIL_FRONT_AND_BACK.0, + "STENCIL_FRONT_AND_BACK", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT.0, + "EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT", + ), + ( + ExternalFenceHandleTypeFlags::EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD.0, + "EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND_EXT.0, + "UPDATE_AFTER_BIND_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for CopyAccelerationStructureModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ImageViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + )]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK => Some("DEBUG_REPORT_CALLBACK"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::OBJECT_TABLE_NVX => Some("OBJECT_TABLE_NVX"), + Self::INDIRECT_COMMANDS_LAYOUT_NVX => Some("INDIRECT_COMMANDS_LAYOUT_NVX"), + Self::VALIDATION_CACHE => Some("VALIDATION_CACHE"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"), + (QueueFlags::RESERVED_5_KHR.0, "RESERVED_5_KHR"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_EXPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_EXPORTABLE", + ), + ( + ExternalFenceFeatureFlags::EXTERNAL_FENCE_FEATURE_IMPORTABLE.0, + "EXTERNAL_FENCE_FEATURE_IMPORTABLE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsNV::TRIANGLE_CULL_DISABLE.0, + "TRIANGLE_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsNV::TRIANGLE_FRONT_COUNTERCLOCKWISE.0, + "TRIANGLE_FRONT_COUNTERCLOCKWISE", + ), + (GeometryInstanceFlagsNV::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsNV::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for GeometryTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESERVED_8 => Some("RESERVED_8"), + Self::RESERVED_4 => Some("RESERVED_4"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_NV", + ), + ( + ExternalMemoryHandleTypeFlagsNV::EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV.0, + "EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_NV", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + ( + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_NV => Some("RAY_TRACING_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} +impl fmt::Display for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + display_flags(f, KNOWN, self.0) + } +} +impl fmt::Display for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + write!(f, "{}", self.0) + } + } +} pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags; diff --git a/ash/tests/ptrchain.rs b/ash/tests/ptrchain.rs deleted file mode 100644 index eca4d09..0000000 --- a/ash/tests/ptrchain.rs +++ /dev/null @@ -1,21 +0,0 @@ -extern crate ash; -use ash::vk; -#[test] -fn test_ptr_chains() { - let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); - let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); - let chain = vec![ - &variable_pointers as *const _ as usize, - &corner as *const _ as usize, - ]; - let mut device_create_info = vk::DeviceCreateInfo::builder() - .push_next(&mut corner) - .push_next(&mut variable_pointers); - let chain2: Vec = unsafe { - vk::ptr_chain_iter(&mut device_create_info) - .skip(1) - .map(|ptr| ptr as usize) - .collect() - }; - assert_eq!(chain, chain2); -} diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 3219ea6..84c388c 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -2200,7 +2200,7 @@ pub fn write_source_code(path: &Path) { use std::os::raw::*; /// Iterates through the pointer chain. Includes the item that is passed into the function. /// Stops at the last `BaseOutStructure` that has a null `p_next` field. - pub unsafe fn ptr_chain_iter( + pub(crate) unsafe fn ptr_chain_iter( ptr: &mut T, ) -> impl Iterator { use std::ptr::null_mut; From cbc96b27b9f6db5436ae8b19e47332896c1f3905 Mon Sep 17 00:00:00 2001 From: Maik Klein Date: Sun, 10 Mar 2019 12:48:14 +0100 Subject: [PATCH 21/21] Update experimental builders --- ash/src/extensions/experimental/amd.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ash/src/extensions/experimental/amd.rs b/ash/src/extensions/experimental/amd.rs index f37f6de..aabc029 100644 --- a/ash/src/extensions/experimental/amd.rs +++ b/ash/src/extensions/experimental/amd.rs @@ -665,8 +665,9 @@ impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { T: ExtendsPhysicalDeviceWaveLimitPropertiesAmd, { unsafe { - let next_ptr = next as *mut _ as *mut BaseOutStructure; - (*next_ptr).p_next = self.inner.p_next as _; + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; self.inner.p_next = next_ptr as _; } self