From 276dd198eee75d97181f4c24657288fa8c5de676 Mon Sep 17 00:00:00 2001 From: Philippe Renon Date: Sun, 13 Jun 2021 22:48:55 +0200 Subject: [PATCH] generator: add missing push_next functions * push_next and Extends traits are generated for all root structs. root structs are now all structs that are extended by other structs! root structs used to be all structs that don't extend any other structs. * the root_structs local variable that is passed around is now a set of Ident (and no String). fixes https://github.com/MaikKlein/ash/issues/229 --- ash/src/vk/definitions.rs | 3182 +++++-------------------------------- generator/src/lib.rs | 70 +- 2 files changed, 434 insertions(+), 2818 deletions(-) diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 521863c7f..5bb792751 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -1273,7 +1273,6 @@ pub struct ApplicationInfoBuilder<'a> { inner: ApplicationInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsApplicationInfo {} impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> { type Target = ApplicationInfo; fn deref(&self) -> &Self::Target { @@ -1306,20 +1305,6 @@ impl<'a> ApplicationInfoBuilder<'a> { self.inner.api_version = api_version; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -2204,7 +2189,6 @@ pub struct MappedMemoryRangeBuilder<'a> { inner: MappedMemoryRange, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMappedMemoryRange {} impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> { type Target = MappedMemoryRange; fn deref(&self) -> &Self::Target { @@ -2229,20 +2213,6 @@ impl<'a> MappedMemoryRangeBuilder<'a> { self.inner.size = size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -2619,7 +2589,6 @@ pub struct CopyDescriptorSetBuilder<'a> { inner: CopyDescriptorSet, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyDescriptorSet {} impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> { type Target = CopyDescriptorSet; fn deref(&self) -> &Self::Target { @@ -2660,20 +2629,6 @@ impl<'a> CopyDescriptorSetBuilder<'a> { self.inner.descriptor_count = descriptor_count; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -2814,7 +2769,6 @@ pub struct BufferViewCreateInfoBuilder<'a> { inner: BufferViewCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferViewCreateInfo {} impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { type Target = BufferViewCreateInfo; fn deref(&self) -> &Self::Target { @@ -2847,20 +2801,6 @@ impl<'a> BufferViewCreateInfoBuilder<'a> { self.inner.range = range; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -3071,7 +3011,6 @@ pub struct MemoryBarrierBuilder<'a> { inner: MemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryBarrier {} impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> { type Target = MemoryBarrier; fn deref(&self) -> &Self::Target { @@ -3092,20 +3031,6 @@ impl<'a> MemoryBarrierBuilder<'a> { self.inner.dst_access_mask = dst_access_mask; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -3155,7 +3080,6 @@ pub struct BufferMemoryBarrierBuilder<'a> { inner: BufferMemoryBarrier, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferMemoryBarrier {} impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> { type Target = BufferMemoryBarrier; fn deref(&self) -> &Self::Target { @@ -3196,20 +3120,6 @@ impl<'a> BufferMemoryBarrierBuilder<'a> { self.inner.size = size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -5317,7 +5227,6 @@ pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> { inner: PipelineInputAssemblyStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineInputAssemblyStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> { type Target = PipelineInputAssemblyStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -5342,23 +5251,6 @@ impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { self.inner.primitive_restart_enable = primitive_restart_enable.into(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -5993,7 +5885,6 @@ pub struct PipelineDynamicStateCreateInfoBuilder<'a> { inner: PipelineDynamicStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineDynamicStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> { type Target = PipelineDynamicStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -6015,20 +5906,6 @@ impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { self.inner.p_dynamic_states = dynamic_states.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -6156,7 +6033,6 @@ pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> { inner: PipelineDepthStencilStateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineDepthStencilStateCreateInfo {} impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> { type Target = PipelineDepthStencilStateCreateInfo; fn deref(&self) -> &Self::Target { @@ -6209,23 +6085,6 @@ impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { self.inner.max_depth_bounds = max_depth_bounds; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -6449,7 +6308,6 @@ pub struct PipelineCacheCreateInfoBuilder<'a> { inner: PipelineCacheCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineCacheCreateInfo {} impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> { type Target = PipelineCacheCreateInfo; fn deref(&self) -> &Self::Target { @@ -6471,20 +6329,6 @@ impl<'a> PipelineCacheCreateInfoBuilder<'a> { self.inner.p_initial_data = initial_data.as_ptr() as *const c_void; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -6582,7 +6426,6 @@ pub struct PipelineLayoutCreateInfoBuilder<'a> { inner: PipelineLayoutCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineLayoutCreateInfo {} impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> { type Target = PipelineLayoutCreateInfo; fn deref(&self) -> &Self::Target { @@ -6609,20 +6452,6 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> { self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -6820,7 +6649,6 @@ pub struct CommandPoolCreateInfoBuilder<'a> { inner: CommandPoolCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandPoolCreateInfo {} impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> { type Target = CommandPoolCreateInfo; fn deref(&self) -> &Self::Target { @@ -6841,20 +6669,6 @@ impl<'a> CommandPoolCreateInfoBuilder<'a> { self.inner.queue_family_index = queue_family_index; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -6896,7 +6710,6 @@ pub struct CommandBufferAllocateInfoBuilder<'a> { inner: CommandBufferAllocateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferAllocateInfo {} impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> { type Target = CommandBufferAllocateInfo; fn deref(&self) -> &Self::Target { @@ -6921,20 +6734,6 @@ impl<'a> CommandBufferAllocateInfoBuilder<'a> { self.inner.command_buffer_count = command_buffer_count; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -7773,7 +7572,6 @@ pub struct EventCreateInfoBuilder<'a> { inner: EventCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsEventCreateInfo {} impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { type Target = EventCreateInfo; fn deref(&self) -> &Self::Target { @@ -7790,20 +7588,6 @@ impl<'a> EventCreateInfoBuilder<'a> { self.inner.flags = flags; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -9901,7 +9685,6 @@ pub struct DisplayModeCreateInfoKHRBuilder<'a> { inner: DisplayModeCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayModeCreateInfoKHR {} impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> { type Target = DisplayModeCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -9922,20 +9705,6 @@ impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { self.inner.parameters = parameters; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10069,7 +9838,6 @@ pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> { inner: DisplaySurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplaySurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> { type Target = DisplaySurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -10114,20 +9882,6 @@ impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { self.inner.image_extent = image_extent; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10324,7 +10078,6 @@ pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> { inner: AndroidSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAndroidSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> { type Target = AndroidSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -10345,20 +10098,6 @@ impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { self.inner.window = window; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10398,7 +10137,6 @@ pub struct ViSurfaceCreateInfoNNBuilder<'a> { inner: ViSurfaceCreateInfoNN, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsViSurfaceCreateInfoNN {} impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> { type Target = ViSurfaceCreateInfoNN; fn deref(&self) -> &Self::Target { @@ -10419,20 +10157,6 @@ impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { self.inner.window = window; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10474,7 +10198,6 @@ pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> { inner: WaylandSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWaylandSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> { type Target = WaylandSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -10499,20 +10222,6 @@ impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { self.inner.surface = surface; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10554,7 +10263,6 @@ pub struct Win32SurfaceCreateInfoKHRBuilder<'a> { inner: Win32SurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsWin32SurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> { type Target = Win32SurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -10579,20 +10287,6 @@ impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { self.inner.hwnd = hwnd; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10634,7 +10328,6 @@ pub struct XlibSurfaceCreateInfoKHRBuilder<'a> { inner: XlibSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsXlibSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> { type Target = XlibSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -10659,20 +10352,6 @@ impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { self.inner.window = window; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10714,7 +10393,6 @@ pub struct XcbSurfaceCreateInfoKHRBuilder<'a> { inner: XcbSurfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsXcbSurfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> { type Target = XcbSurfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -10739,20 +10417,6 @@ impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { self.inner.window = window; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10794,7 +10458,6 @@ pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> { inner: DirectFBSurfaceCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDirectFBSurfaceCreateInfoEXT {} impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> { type Target = DirectFBSurfaceCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -10819,20 +10482,6 @@ impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> { self.inner.surface = surface; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10872,7 +10521,6 @@ pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { inner: ImagePipeSurfaceCreateInfoFUCHSIA, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImagePipeSurfaceCreateInfoFUCHSIA {} impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { type Target = ImagePipeSurfaceCreateInfoFUCHSIA; fn deref(&self) -> &Self::Target { @@ -10893,23 +10541,6 @@ impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { self.inner.image_pipe_handle = image_pipe_handle; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -10949,7 +10580,6 @@ pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { inner: StreamDescriptorSurfaceCreateInfoGGP, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsStreamDescriptorSurfaceCreateInfoGGP {} impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { type Target = StreamDescriptorSurfaceCreateInfoGGP; fn deref(&self) -> &Self::Target { @@ -10970,23 +10600,6 @@ impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { self.inner.stream_descriptor = stream_descriptor; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -11028,7 +10641,6 @@ pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> { inner: ScreenSurfaceCreateInfoQNX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsScreenSurfaceCreateInfoQNX {} impl<'a> ::std::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> { type Target = ScreenSurfaceCreateInfoQNX; fn deref(&self) -> &Self::Target { @@ -11053,20 +10665,6 @@ impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> { self.inner.window = window; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -11677,7 +11275,6 @@ pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> { inner: DebugMarkerObjectNameInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerObjectNameInfoEXT {} impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> { type Target = DebugMarkerObjectNameInfoEXT; fn deref(&self) -> &Self::Target { @@ -11702,20 +11299,6 @@ impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { self.inner.p_object_name = object_name.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -11761,7 +11344,6 @@ pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> { inner: DebugMarkerObjectTagInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerObjectTagInfoEXT {} impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> { type Target = DebugMarkerObjectTagInfoEXT; fn deref(&self) -> &Self::Target { @@ -11791,20 +11373,6 @@ impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { self.inner.p_tag = tag.as_ptr() as *const c_void; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -11844,7 +11412,6 @@ pub struct DebugMarkerMarkerInfoEXTBuilder<'a> { inner: DebugMarkerMarkerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugMarkerMarkerInfoEXT {} impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> { type Target = DebugMarkerMarkerInfoEXT; fn deref(&self) -> &Self::Target { @@ -11865,20 +11432,6 @@ impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { self.inner.color = color; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -12478,6 +12031,11 @@ pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { @@ -12588,7 +12146,6 @@ pub struct PrivateDataSlotCreateInfoEXTBuilder<'a> { inner: PrivateDataSlotCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPrivateDataSlotCreateInfoEXT {} impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoEXTBuilder<'a> { type Target = PrivateDataSlotCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -12605,20 +12162,6 @@ impl<'a> PrivateDataSlotCreateInfoEXTBuilder<'a> { self.inner.flags = flags; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -12656,6 +12199,8 @@ pub struct PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { inner: PhysicalDevicePrivateDataFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { @@ -12847,7 +12392,6 @@ pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> { inner: GraphicsShaderGroupCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGraphicsShaderGroupCreateInfoNV {} impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> { type Target = GraphicsShaderGroupCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -12879,20 +12423,6 @@ impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> { self.inner.p_tessellation_state = tessellation_state; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -13259,7 +12789,6 @@ pub struct IndirectCommandsLayoutTokenNVBuilder<'a> { inner: IndirectCommandsLayoutTokenNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsIndirectCommandsLayoutTokenNV {} impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> { type Target = IndirectCommandsLayoutTokenNV; fn deref(&self) -> &Self::Target { @@ -13328,20 +12857,6 @@ impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> { self.inner.p_index_type_values = index_type_values.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -13389,7 +12904,6 @@ pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> { inner: IndirectCommandsLayoutCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsIndirectCommandsLayoutCreateInfoNV {} impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> { type Target = IndirectCommandsLayoutCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -13420,23 +12934,6 @@ impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> { self.inner.p_stream_strides = stream_strides.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -13498,7 +12995,6 @@ pub struct GeneratedCommandsInfoNVBuilder<'a> { inner: GeneratedCommandsInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeneratedCommandsInfoNV {} impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> { type Target = GeneratedCommandsInfoNV; fn deref(&self) -> &Self::Target { @@ -13563,20 +13059,6 @@ impl<'a> GeneratedCommandsInfoNVBuilder<'a> { self.inner.sequences_index_offset = sequences_index_offset; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -13620,7 +13102,6 @@ pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { inner: GeneratedCommandsMemoryRequirementsInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeneratedCommandsMemoryRequirementsInfoNV {} impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { type Target = GeneratedCommandsMemoryRequirementsInfoNV; fn deref(&self) -> &Self::Target { @@ -13652,23 +13133,6 @@ impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { self.inner.max_sequences_count = max_sequences_count; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -13708,6 +13172,7 @@ pub struct PhysicalDeviceFeatures2Builder<'a> { } unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {} +pub unsafe trait ExtendsPhysicalDeviceFeatures2 {} impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> { type Target = PhysicalDeviceFeatures2; fn deref(&self) -> &Self::Target { @@ -13724,6 +13189,20 @@ impl<'a> PhysicalDeviceFeatures2Builder<'a> { self.inner.features = features; self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = 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 + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -14199,7 +13678,6 @@ pub struct SparseImageFormatProperties2Builder<'a> { inner: SparseImageFormatProperties2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSparseImageFormatProperties2 {} impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> { type Target = SparseImageFormatProperties2; fn deref(&self) -> &Self::Target { @@ -14216,20 +13694,6 @@ impl<'a> SparseImageFormatProperties2Builder<'a> { self.inner.properties = properties; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -14275,7 +13739,6 @@ pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> { inner: PhysicalDeviceSparseImageFormatInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceSparseImageFormatInfo2 {} impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { type Target = PhysicalDeviceSparseImageFormatInfo2; fn deref(&self) -> &Self::Target { @@ -14308,23 +13771,6 @@ impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { self.inner.tiling = tiling; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -14730,6 +14176,8 @@ pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> { inner: PhysicalDeviceVariablePointersFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> { @@ -14973,7 +14421,6 @@ pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> { inner: PhysicalDeviceExternalBufferInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo {} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> { type Target = PhysicalDeviceExternalBufferInfo; fn deref(&self) -> &Self::Target { @@ -14998,23 +14445,6 @@ impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -15052,7 +14482,6 @@ pub struct ExternalBufferPropertiesBuilder<'a> { inner: ExternalBufferProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalBufferProperties {} impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> { type Target = ExternalBufferProperties; fn deref(&self) -> &Self::Target { @@ -15072,20 +14501,6 @@ impl<'a> ExternalBufferPropertiesBuilder<'a> { self.inner.external_memory_properties = external_memory_properties; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -15562,7 +14977,6 @@ pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { inner: MemoryZirconHandlePropertiesFUCHSIA, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryZirconHandlePropertiesFUCHSIA {} impl<'a> ::std::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { type Target = MemoryZirconHandlePropertiesFUCHSIA; fn deref(&self) -> &Self::Target { @@ -15579,23 +14993,6 @@ impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -15635,7 +15032,6 @@ pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { inner: MemoryGetZirconHandleInfoFUCHSIA, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetZirconHandleInfoFUCHSIA {} impl<'a> ::std::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { type Target = MemoryGetZirconHandleInfoFUCHSIA; fn deref(&self) -> &Self::Target { @@ -15656,23 +15052,6 @@ impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -15710,7 +15089,6 @@ pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> { inner: MemoryWin32HandlePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryWin32HandlePropertiesKHR {} impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> { type Target = MemoryWin32HandlePropertiesKHR; fn deref(&self) -> &Self::Target { @@ -15727,20 +15105,6 @@ impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -15780,7 +15144,6 @@ pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> { inner: MemoryGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> { type Target = MemoryGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -15801,20 +15164,6 @@ impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -15913,7 +15262,6 @@ pub struct MemoryFdPropertiesKHRBuilder<'a> { inner: MemoryFdPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryFdPropertiesKHR {} impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> { type Target = MemoryFdPropertiesKHR; fn deref(&self) -> &Self::Target { @@ -15930,20 +15278,6 @@ impl<'a> MemoryFdPropertiesKHRBuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -15983,7 +15317,6 @@ pub struct MemoryGetFdInfoKHRBuilder<'a> { inner: MemoryGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetFdInfoKHR {} impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> { type Target = MemoryGetFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -16004,20 +15337,6 @@ impl<'a> MemoryGetFdInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16220,7 +15539,6 @@ pub struct ExternalSemaphorePropertiesBuilder<'a> { inner: ExternalSemaphoreProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalSemaphoreProperties {} impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> { type Target = ExternalSemaphoreProperties; fn deref(&self) -> &Self::Target { @@ -16254,20 +15572,6 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> { self.inner.external_semaphore_features = external_semaphore_features; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16368,7 +15672,6 @@ pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { inner: ImportSemaphoreWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportSemaphoreWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { type Target = ImportSemaphoreWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -16401,23 +15704,6 @@ impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16591,7 +15877,6 @@ pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> { inner: SemaphoreGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreGetWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { type Target = SemaphoreGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -16612,20 +15897,6 @@ impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16669,7 +15940,6 @@ pub struct ImportSemaphoreFdInfoKHRBuilder<'a> { inner: ImportSemaphoreFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportSemaphoreFdInfoKHR {} impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> { type Target = ImportSemaphoreFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -16698,20 +15968,6 @@ impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { self.inner.fd = fd; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16751,7 +16007,6 @@ pub struct SemaphoreGetFdInfoKHRBuilder<'a> { inner: SemaphoreGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreGetFdInfoKHR {} impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> { type Target = SemaphoreGetFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -16772,20 +16027,6 @@ impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16829,7 +16070,6 @@ pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { inner: ImportSemaphoreZirconHandleInfoFUCHSIA, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportSemaphoreZirconHandleInfoFUCHSIA {} impl<'a> ::std::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { type Target = ImportSemaphoreZirconHandleInfoFUCHSIA; fn deref(&self) -> &Self::Target { @@ -16858,23 +16098,6 @@ impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { self.inner.zircon_handle = zircon_handle; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16914,7 +16137,6 @@ pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { inner: SemaphoreGetZirconHandleInfoFUCHSIA, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreGetZirconHandleInfoFUCHSIA {} impl<'a> ::std::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { type Target = SemaphoreGetZirconHandleInfoFUCHSIA; fn deref(&self) -> &Self::Target { @@ -16935,23 +16157,6 @@ impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -16989,7 +16194,6 @@ pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> { inner: PhysicalDeviceExternalFenceInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceExternalFenceInfo {} impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> { type Target = PhysicalDeviceExternalFenceInfo; fn deref(&self) -> &Self::Target { @@ -17006,20 +16210,6 @@ impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -17061,7 +16251,6 @@ pub struct ExternalFencePropertiesBuilder<'a> { inner: ExternalFenceProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsExternalFenceProperties {} impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> { type Target = ExternalFenceProperties; fn deref(&self) -> &Self::Target { @@ -17095,20 +16284,6 @@ impl<'a> ExternalFencePropertiesBuilder<'a> { self.inner.external_fence_features = external_fence_features; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -17209,7 +16384,6 @@ pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> { inner: ImportFenceWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportFenceWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> { type Target = ImportFenceWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -17242,20 +16416,6 @@ impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { self.inner.name = name; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -17362,7 +16522,6 @@ pub struct FenceGetWin32HandleInfoKHRBuilder<'a> { inner: FenceGetWin32HandleInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceGetWin32HandleInfoKHR {} impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> { type Target = FenceGetWin32HandleInfoKHR; fn deref(&self) -> &Self::Target { @@ -17383,20 +16542,6 @@ impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -17440,7 +16585,6 @@ pub struct ImportFenceFdInfoKHRBuilder<'a> { inner: ImportFenceFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImportFenceFdInfoKHR {} impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> { type Target = ImportFenceFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -17469,20 +16613,6 @@ impl<'a> ImportFenceFdInfoKHRBuilder<'a> { self.inner.fd = fd; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -17522,7 +16652,6 @@ pub struct FenceGetFdInfoKHRBuilder<'a> { inner: FenceGetFdInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFenceGetFdInfoKHR {} impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> { type Target = FenceGetFdInfoKHR; fn deref(&self) -> &Self::Target { @@ -17543,20 +16672,6 @@ impl<'a> FenceGetFdInfoKHRBuilder<'a> { self.inner.handle_type = handle_type; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -17598,6 +16713,8 @@ pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> { inner: PhysicalDeviceMultiviewFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> { @@ -17818,7 +16935,6 @@ pub struct SurfaceCapabilities2EXTBuilder<'a> { inner: SurfaceCapabilities2EXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceCapabilities2EXT {} impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> { type Target = SurfaceCapabilities2EXT; fn deref(&self) -> &Self::Target { @@ -17881,20 +16997,6 @@ impl<'a> SurfaceCapabilities2EXTBuilder<'a> { self.inner.supported_surface_counters = supported_surface_counters; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -17932,7 +17034,6 @@ pub struct DisplayPowerInfoEXTBuilder<'a> { inner: DisplayPowerInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPowerInfoEXT {} impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> { type Target = DisplayPowerInfoEXT; fn deref(&self) -> &Self::Target { @@ -17949,20 +17050,6 @@ impl<'a> DisplayPowerInfoEXTBuilder<'a> { self.inner.power_state = power_state; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -18000,7 +17087,6 @@ pub struct DeviceEventInfoEXTBuilder<'a> { inner: DeviceEventInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceEventInfoEXT {} impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> { type Target = DeviceEventInfoEXT; fn deref(&self) -> &Self::Target { @@ -18017,20 +17103,6 @@ impl<'a> DeviceEventInfoEXTBuilder<'a> { self.inner.device_event = device_event; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -18068,7 +17140,6 @@ pub struct DisplayEventInfoEXTBuilder<'a> { inner: DisplayEventInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayEventInfoEXT {} impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> { type Target = DisplayEventInfoEXT; fn deref(&self) -> &Self::Target { @@ -18085,20 +17156,6 @@ impl<'a> DisplayEventInfoEXTBuilder<'a> { self.inner.display_event = display_event; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -18195,7 +17252,6 @@ pub struct PhysicalDeviceGroupPropertiesBuilder<'a> { inner: PhysicalDeviceGroupProperties, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceGroupProperties {} impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> { type Target = PhysicalDeviceGroupProperties; fn deref(&self) -> &Self::Target { @@ -18223,20 +17279,6 @@ impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { self.inner.subset_allocation = subset_allocation.into(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -18887,7 +17929,6 @@ pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> { inner: DeviceGroupPresentCapabilitiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceGroupPresentCapabilitiesKHR {} impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { type Target = DeviceGroupPresentCapabilitiesKHR; fn deref(&self) -> &Self::Target { @@ -18908,23 +17949,6 @@ impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { self.inner.modes = modes; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -19086,7 +18110,6 @@ pub struct AcquireNextImageInfoKHRBuilder<'a> { inner: AcquireNextImageInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAcquireNextImageInfoKHR {} impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> { type Target = AcquireNextImageInfoKHR; fn deref(&self) -> &Self::Target { @@ -19119,20 +18142,6 @@ impl<'a> AcquireNextImageInfoKHRBuilder<'a> { self.inner.device_mask = device_mask; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -19428,7 +18437,6 @@ pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> { inner: DescriptorUpdateTemplateCreateInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDescriptorUpdateTemplateCreateInfo {} impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> { type Target = DescriptorUpdateTemplateCreateInfo; fn deref(&self) -> &Self::Target { @@ -19473,23 +18481,6 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { self.inner.set = set; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -19588,7 +18579,6 @@ pub struct HdrMetadataEXTBuilder<'a> { inner: HdrMetadataEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsHdrMetadataEXT {} impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> { type Target = HdrMetadataEXT; fn deref(&self) -> &Self::Target { @@ -19633,20 +18623,6 @@ impl<'a> HdrMetadataEXTBuilder<'a> { self.inner.max_frame_average_light_level = max_frame_average_light_level; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -20005,7 +18981,6 @@ pub struct IOSSurfaceCreateInfoMVKBuilder<'a> { inner: IOSSurfaceCreateInfoMVK, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsIOSSurfaceCreateInfoMVK {} impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> { type Target = IOSSurfaceCreateInfoMVK; fn deref(&self) -> &Self::Target { @@ -20026,20 +19001,6 @@ impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.p_view = view; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -20079,7 +19040,6 @@ pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { inner: MacOSSurfaceCreateInfoMVK, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMacOSSurfaceCreateInfoMVK {} impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { type Target = MacOSSurfaceCreateInfoMVK; fn deref(&self) -> &Self::Target { @@ -20100,20 +19060,6 @@ impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { self.inner.p_view = view; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -20153,7 +19099,6 @@ pub struct MetalSurfaceCreateInfoEXTBuilder<'a> { inner: MetalSurfaceCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMetalSurfaceCreateInfoEXT {} impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> { type Target = MetalSurfaceCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -20174,20 +19119,6 @@ impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> { self.inner.p_layer = layer; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -20910,7 +19841,6 @@ pub struct SurfaceFormat2KHRBuilder<'a> { inner: SurfaceFormat2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSurfaceFormat2KHR {} impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { type Target = SurfaceFormat2KHR; fn deref(&self) -> &Self::Target { @@ -20927,20 +19857,6 @@ impl<'a> SurfaceFormat2KHRBuilder<'a> { self.inner.surface_format = surface_format; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -20978,7 +19894,6 @@ pub struct DisplayProperties2KHRBuilder<'a> { inner: DisplayProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayProperties2KHR {} impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> { type Target = DisplayProperties2KHR; fn deref(&self) -> &Self::Target { @@ -20995,20 +19910,6 @@ impl<'a> DisplayProperties2KHRBuilder<'a> { self.inner.display_properties = display_properties; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21046,7 +19947,6 @@ pub struct DisplayPlaneProperties2KHRBuilder<'a> { inner: DisplayPlaneProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneProperties2KHR {} impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> { type Target = DisplayPlaneProperties2KHR; fn deref(&self) -> &Self::Target { @@ -21066,20 +19966,6 @@ impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { self.inner.display_plane_properties = display_plane_properties; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21117,7 +20003,6 @@ pub struct DisplayModeProperties2KHRBuilder<'a> { inner: DisplayModeProperties2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayModeProperties2KHR {} impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> { type Target = DisplayModeProperties2KHR; fn deref(&self) -> &Self::Target { @@ -21137,20 +20022,6 @@ impl<'a> DisplayModeProperties2KHRBuilder<'a> { self.inner.display_mode_properties = display_mode_properties; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21190,7 +20061,6 @@ pub struct DisplayPlaneInfo2KHRBuilder<'a> { inner: DisplayPlaneInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneInfo2KHR {} impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> { type Target = DisplayPlaneInfo2KHR; fn deref(&self) -> &Self::Target { @@ -21211,20 +20081,6 @@ impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { self.inner.plane_index = plane_index; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21262,7 +20118,6 @@ pub struct DisplayPlaneCapabilities2KHRBuilder<'a> { inner: DisplayPlaneCapabilities2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDisplayPlaneCapabilities2KHR {} impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> { type Target = DisplayPlaneCapabilities2KHR; fn deref(&self) -> &Self::Target { @@ -21279,20 +20134,6 @@ impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { self.inner.capabilities = capabilities; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21394,6 +20235,8 @@ pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> { inner: PhysicalDevice16BitStorageFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {} impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> { @@ -21538,6 +20381,11 @@ pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> { @@ -21596,7 +20444,6 @@ pub struct BufferMemoryRequirementsInfo2Builder<'a> { inner: BufferMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferMemoryRequirementsInfo2 {} impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> { type Target = BufferMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { @@ -21613,20 +20460,6 @@ impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { self.inner.buffer = buffer; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21732,7 +20565,6 @@ pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> { inner: ImageSparseMemoryRequirementsInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageSparseMemoryRequirementsInfo2 {} impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> { type Target = ImageSparseMemoryRequirementsInfo2; fn deref(&self) -> &Self::Target { @@ -21749,23 +20581,6 @@ impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { self.inner.image = image; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -21871,7 +20686,6 @@ pub struct SparseImageMemoryRequirements2Builder<'a> { inner: SparseImageMemoryRequirements2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSparseImageMemoryRequirements2 {} impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> { type Target = SparseImageMemoryRequirements2; fn deref(&self) -> &Self::Target { @@ -21891,20 +20705,6 @@ impl<'a> SparseImageMemoryRequirements2Builder<'a> { self.inner.memory_requirements = memory_requirements; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -22518,6 +21318,11 @@ pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { inner: PhysicalDeviceSamplerYcbcrConversionFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { @@ -22698,7 +21503,6 @@ pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> { inner: ConditionalRenderingBeginInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsConditionalRenderingBeginInfoEXT {} impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> { type Target = ConditionalRenderingBeginInfoEXT; fn deref(&self) -> &Self::Target { @@ -22723,23 +21527,6 @@ impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { self.inner.flags = flags; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -22832,6 +21619,8 @@ pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { inner: PhysicalDeviceProtectedMemoryFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { @@ -22949,7 +21738,6 @@ pub struct DeviceQueueInfo2Builder<'a> { inner: DeviceQueueInfo2, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceQueueInfo2 {} impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> { type Target = DeviceQueueInfo2; fn deref(&self) -> &Self::Target { @@ -22974,20 +21762,6 @@ impl<'a> DeviceQueueInfo2Builder<'a> { self.inner.queue_index = queue_index; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -23616,7 +22390,6 @@ pub struct MultisamplePropertiesEXTBuilder<'a> { inner: MultisamplePropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMultisamplePropertiesEXT {} impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> { type Target = MultisamplePropertiesEXT; fn deref(&self) -> &Self::Target { @@ -23636,20 +22409,6 @@ impl<'a> MultisamplePropertiesEXTBuilder<'a> { self.inner.max_sample_location_grid_size = max_sample_location_grid_size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -23742,6 +22501,11 @@ pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { @@ -23980,6 +22744,11 @@ pub struct PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { inner: PhysicalDeviceInlineUniformBlockFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> { @@ -24417,7 +23186,6 @@ pub struct ValidationCacheCreateInfoEXTBuilder<'a> { inner: ValidationCacheCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsValidationCacheCreateInfoEXT {} impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> { type Target = ValidationCacheCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -24439,20 +23207,6 @@ impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { self.inner.p_initial_data = initial_data.as_ptr() as *const c_void; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -24674,6 +23428,11 @@ pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { inner: PhysicalDeviceShaderDrawParametersFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { @@ -24731,6 +23490,8 @@ pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { inner: PhysicalDeviceShaderFloat16Int8Features, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { @@ -24986,6 +23747,8 @@ pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { inner: PhysicalDeviceHostQueryResetFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { @@ -25096,7 +23859,6 @@ pub struct NativeBufferANDROIDBuilder<'a> { inner: NativeBufferANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsNativeBufferANDROID {} impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> { type Target = NativeBufferANDROID; fn deref(&self) -> &Self::Target { @@ -25129,20 +23891,6 @@ impl<'a> NativeBufferANDROIDBuilder<'a> { self.inner.usage2 = usage2; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -25180,7 +23928,6 @@ pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> { inner: SwapchainImageCreateInfoANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSwapchainImageCreateInfoANDROID {} impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> { type Target = SwapchainImageCreateInfoANDROID; fn deref(&self) -> &Self::Target { @@ -25197,20 +23944,6 @@ impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> { self.inner.usage = usage; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -25248,7 +23981,6 @@ pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { inner: PhysicalDevicePresentationPropertiesANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDevicePresentationPropertiesANDROID {} impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { type Target = PhysicalDevicePresentationPropertiesANDROID; fn deref(&self) -> &Self::Target { @@ -25265,23 +23997,6 @@ impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { self.inner.shared_image = shared_image.into(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -25525,7 +24240,6 @@ pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> { inner: DebugUtilsObjectNameInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsObjectNameInfoEXT {} impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> { type Target = DebugUtilsObjectNameInfoEXT; fn deref(&self) -> &Self::Target { @@ -25550,20 +24264,6 @@ impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { self.inner.p_object_name = object_name.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -25609,7 +24309,6 @@ pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> { inner: DebugUtilsObjectTagInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsObjectTagInfoEXT {} impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> { type Target = DebugUtilsObjectTagInfoEXT; fn deref(&self) -> &Self::Target { @@ -25639,20 +24338,6 @@ impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { self.inner.p_tag = tag.as_ptr() as *const c_void; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -25692,7 +24377,6 @@ pub struct DebugUtilsLabelEXTBuilder<'a> { inner: DebugUtilsLabelEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsLabelEXT {} impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> { type Target = DebugUtilsLabelEXT; fn deref(&self) -> &Self::Target { @@ -25713,20 +24397,6 @@ impl<'a> DebugUtilsLabelEXTBuilder<'a> { self.inner.color = color; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -25880,7 +24550,6 @@ pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> { inner: DebugUtilsMessengerCallbackDataEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {} impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { type Target = DebugUtilsMessengerCallbackDataEXT; fn deref(&self) -> &Self::Target { @@ -25924,23 +24593,6 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { self.inner.p_objects = objects.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -25978,6 +24630,11 @@ pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { @@ -26129,7 +24786,6 @@ pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> { inner: DeviceMemoryReportCallbackDataEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceMemoryReportCallbackDataEXT {} impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> { type Target = DeviceMemoryReportCallbackDataEXT; fn deref(&self) -> &Self::Target { @@ -26170,23 +24826,6 @@ impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> { self.inner.heap_index = heap_index; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -26285,7 +24924,6 @@ pub struct MemoryHostPointerPropertiesEXTBuilder<'a> { inner: MemoryHostPointerPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryHostPointerPropertiesEXT {} impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> { type Target = MemoryHostPointerPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -26302,20 +24940,6 @@ impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { self.inner.memory_type_bits = memory_type_bits; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -26546,7 +25170,6 @@ pub struct CalibratedTimestampInfoEXTBuilder<'a> { inner: CalibratedTimestampInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCalibratedTimestampInfoEXT {} impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> { type Target = CalibratedTimestampInfoEXT; fn deref(&self) -> &Self::Target { @@ -26563,20 +25186,6 @@ impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { self.inner.time_domain = time_domain; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -26928,6 +25537,8 @@ pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { inner: PhysicalDeviceDescriptorIndexingFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { @@ -28157,7 +26768,6 @@ pub struct SubpassBeginInfoBuilder<'a> { inner: SubpassBeginInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassBeginInfo {} impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> { type Target = SubpassBeginInfo; fn deref(&self) -> &Self::Target { @@ -28174,20 +26784,6 @@ impl<'a> SubpassBeginInfoBuilder<'a> { self.inner.contents = contents; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -28223,7 +26819,6 @@ pub struct SubpassEndInfoBuilder<'a> { inner: SubpassEndInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSubpassEndInfo {} impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> { type Target = SubpassEndInfo; fn deref(&self) -> &Self::Target { @@ -28236,20 +26831,6 @@ impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> { } } impl<'a> SubpassEndInfoBuilder<'a> { - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -28287,6 +26868,8 @@ pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { inner: PhysicalDeviceTimelineSemaphoreFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { @@ -28542,7 +27125,6 @@ pub struct SemaphoreWaitInfoBuilder<'a> { inner: SemaphoreWaitInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreWaitInfo {} impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> { type Target = SemaphoreWaitInfo; fn deref(&self) -> &Self::Target { @@ -28569,20 +27151,6 @@ impl<'a> SemaphoreWaitInfoBuilder<'a> { self.inner.p_values = values.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -28622,7 +27190,6 @@ pub struct SemaphoreSignalInfoBuilder<'a> { inner: SemaphoreSignalInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreSignalInfo {} impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> { type Target = SemaphoreSignalInfo; fn deref(&self) -> &Self::Target { @@ -28643,20 +27210,6 @@ impl<'a> SemaphoreSignalInfoBuilder<'a> { self.inner.value = value; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -29126,7 +27679,6 @@ pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { inner: MemoryGetAndroidHardwareBufferInfoANDROID, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsMemoryGetAndroidHardwareBufferInfoANDROID {} impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { type Target = MemoryGetAndroidHardwareBufferInfoANDROID; fn deref(&self) -> &Self::Target { @@ -29143,23 +27695,6 @@ impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { self.inner.memory = memory; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -29428,6 +27963,8 @@ pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> { inner: PhysicalDevice8BitStorageFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {} impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> { @@ -29497,6 +28034,11 @@ pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { inner: PhysicalDeviceConditionalRenderingFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { @@ -29563,6 +28105,8 @@ pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { inner: PhysicalDeviceVulkanMemoryModelFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { @@ -29636,6 +28180,8 @@ pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { inner: PhysicalDeviceShaderAtomicInt64Features, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { @@ -29717,6 +28263,11 @@ pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { @@ -29836,6 +28387,11 @@ pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { @@ -29963,7 +28519,6 @@ pub struct CheckpointDataNVBuilder<'a> { inner: CheckpointDataNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCheckpointDataNV {} impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> { type Target = CheckpointDataNV; fn deref(&self) -> &Self::Target { @@ -29984,20 +28539,6 @@ impl<'a> CheckpointDataNVBuilder<'a> { self.inner.p_checkpoint_marker = checkpoint_marker; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -30242,6 +28783,8 @@ pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { inner: PhysicalDeviceASTCDecodeFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { @@ -30299,6 +28842,11 @@ pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { inner: PhysicalDeviceTransformFeedbackFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { @@ -30560,6 +29108,11 @@ pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> { @@ -30682,6 +29235,8 @@ pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { inner: PhysicalDeviceExclusiveScissorFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { @@ -30801,6 +29356,11 @@ pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { inner: PhysicalDeviceCornerSampledImageFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { @@ -30858,6 +29418,11 @@ pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> { @@ -30923,6 +29488,11 @@ pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> { @@ -30981,6 +29551,11 @@ pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { inner: PhysicalDeviceShaderImageFootprintFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { @@ -31036,6 +29611,14 @@ pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV +{ +} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> { @@ -31229,6 +29812,8 @@ pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { inner: PhysicalDeviceShadingRateImageFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { @@ -31552,6 +30137,8 @@ pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { inner: PhysicalDeviceMeshShaderFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { @@ -31799,7 +30386,6 @@ pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> { inner: RayTracingShaderGroupCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoNV {} impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> { type Target = RayTracingShaderGroupCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -31832,23 +30418,6 @@ impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { self.inner.intersection_shader = intersection_shader; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -31896,7 +30465,6 @@ pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> { inner: RayTracingShaderGroupCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoKHR {} impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> { type Target = RayTracingShaderGroupCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -31936,23 +30504,6 @@ impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> { self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32254,7 +30805,6 @@ pub struct GeometryTrianglesNVBuilder<'a> { inner: GeometryTrianglesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryTrianglesNV {} impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> { type Target = GeometryTrianglesNV; fn deref(&self) -> &Self::Target { @@ -32311,20 +30861,6 @@ impl<'a> GeometryTrianglesNVBuilder<'a> { self.inner.transform_offset = transform_offset; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32368,7 +30904,6 @@ pub struct GeometryAABBNVBuilder<'a> { inner: GeometryAABBNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryAABBNV {} impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> { type Target = GeometryAABBNV; fn deref(&self) -> &Self::Target { @@ -32397,20 +30932,6 @@ impl<'a> GeometryAABBNVBuilder<'a> { self.inner.offset = offset; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32499,7 +31020,6 @@ pub struct GeometryNVBuilder<'a> { inner: GeometryNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsGeometryNV {} impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> { type Target = GeometryNV; fn deref(&self) -> &Self::Target { @@ -32524,20 +31044,6 @@ impl<'a> GeometryNVBuilder<'a> { self.inner.flags = flags; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32583,7 +31089,6 @@ pub struct AccelerationStructureInfoNVBuilder<'a> { inner: AccelerationStructureInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureInfoNV {} impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> { type Target = AccelerationStructureInfoNV; fn deref(&self) -> &Self::Target { @@ -32613,20 +31118,6 @@ impl<'a> AccelerationStructureInfoNVBuilder<'a> { self.inner.p_geometries = geometries.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32666,7 +31157,6 @@ pub struct AccelerationStructureCreateInfoNVBuilder<'a> { inner: AccelerationStructureCreateInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {} impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> { type Target = AccelerationStructureCreateInfoNV; fn deref(&self) -> &Self::Target { @@ -32687,23 +31177,6 @@ impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { self.inner.info = info; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32749,7 +31222,6 @@ pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> { inner: BindAccelerationStructureMemoryInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoNV {} impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> { type Target = BindAccelerationStructureMemoryInfoNV; fn deref(&self) -> &Self::Target { @@ -32782,23 +31254,6 @@ impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { self.inner.p_device_indices = device_indices.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -32960,7 +31415,6 @@ pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { inner: AccelerationStructureMemoryRequirementsInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoNV {} impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { type Target = AccelerationStructureMemoryRequirementsInfoNV; fn deref(&self) -> &Self::Target { @@ -32984,23 +31438,6 @@ impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { self.inner.acceleration_structure = acceleration_structure; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -33046,6 +31483,11 @@ pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { inner: PhysicalDeviceAccelerationStructureFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { @@ -33142,6 +31584,11 @@ pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { inner: PhysicalDeviceRayTracingPipelineFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { @@ -33230,6 +31677,8 @@ pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { inner: PhysicalDeviceRayQueryFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { @@ -34031,7 +32480,6 @@ pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> { inner: ImageDrmFormatModifierPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageDrmFormatModifierPropertiesEXT {} impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { type Target = ImageDrmFormatModifierPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -34048,23 +32496,6 @@ impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { self.inner.drm_format_modifier = drm_format_modifier; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -34221,6 +32652,11 @@ pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { @@ -34288,6 +32724,11 @@ pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { @@ -34562,6 +33003,8 @@ pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { inner: PhysicalDeviceScalarBlockLayoutFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { @@ -34672,6 +33115,11 @@ pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { inner: PhysicalDeviceUniformBufferStandardLayoutFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> { @@ -34730,6 +33178,8 @@ pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { inner: PhysicalDeviceDepthClipEnableFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { @@ -34916,6 +33366,8 @@ pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { inner: PhysicalDeviceMemoryPriorityFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { @@ -35030,6 +33482,11 @@ pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { inner: PhysicalDeviceBufferDeviceAddressFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { @@ -35104,6 +33561,11 @@ pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { @@ -35174,7 +33636,6 @@ pub struct BufferDeviceAddressInfoBuilder<'a> { inner: BufferDeviceAddressInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferDeviceAddressInfo {} impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> { type Target = BufferDeviceAddressInfo; fn deref(&self) -> &Self::Target { @@ -35191,20 +33652,6 @@ impl<'a> BufferDeviceAddressInfoBuilder<'a> { self.inner.buffer = buffer; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -35474,6 +33921,11 @@ pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { inner: PhysicalDeviceImagelessFramebufferFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {} impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { @@ -35602,7 +34054,6 @@ pub struct FramebufferAttachmentImageInfoBuilder<'a> { inner: FramebufferAttachmentImageInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFramebufferAttachmentImageInfo {} impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> { type Target = FramebufferAttachmentImageInfo; fn deref(&self) -> &Self::Target { @@ -35640,20 +34091,6 @@ impl<'a> FramebufferAttachmentImageInfoBuilder<'a> { self.inner.p_view_formats = view_formats.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -35749,6 +34186,11 @@ pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> { inner: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'_> { @@ -35809,6 +34251,11 @@ pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { inner: PhysicalDeviceCooperativeMatrixFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { @@ -35947,7 +34394,6 @@ pub struct CooperativeMatrixPropertiesNVBuilder<'a> { inner: CooperativeMatrixPropertiesNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCooperativeMatrixPropertiesNV {} impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> { type Target = CooperativeMatrixPropertiesNV; fn deref(&self) -> &Self::Target { @@ -35992,20 +34438,6 @@ impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> { self.inner.scope = scope; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -36043,6 +34475,11 @@ pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { @@ -36102,7 +34539,6 @@ pub struct ImageViewHandleInfoNVXBuilder<'a> { inner: ImageViewHandleInfoNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageViewHandleInfoNVX {} impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> { type Target = ImageViewHandleInfoNVX; fn deref(&self) -> &Self::Target { @@ -36127,20 +34563,6 @@ impl<'a> ImageViewHandleInfoNVXBuilder<'a> { self.inner.sampler = sampler; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -36180,7 +34602,6 @@ pub struct ImageViewAddressPropertiesNVXBuilder<'a> { inner: ImageViewAddressPropertiesNVX, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageViewAddressPropertiesNVX {} impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> { type Target = ImageViewAddressPropertiesNVX; fn deref(&self) -> &Self::Target { @@ -36201,20 +34622,6 @@ impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> { self.inner.size = size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -36618,6 +35025,11 @@ pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { inner: PhysicalDevicePerformanceQueryFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { @@ -36751,7 +35163,6 @@ pub struct PerformanceCounterKHRBuilder<'a> { inner: PerformanceCounterKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPerformanceCounterKHR {} impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> { type Target = PerformanceCounterKHR; fn deref(&self) -> &Self::Target { @@ -36780,20 +35191,6 @@ impl<'a> PerformanceCounterKHRBuilder<'a> { self.inner.uuid = uuid; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -36855,7 +35252,6 @@ pub struct PerformanceCounterDescriptionKHRBuilder<'a> { inner: PerformanceCounterDescriptionKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPerformanceCounterDescriptionKHR {} impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> { type Target = PerformanceCounterDescriptionKHR; fn deref(&self) -> &Self::Target { @@ -36884,23 +35280,6 @@ impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> { self.inner.description = description; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37020,7 +35399,6 @@ pub struct AcquireProfilingLockInfoKHRBuilder<'a> { inner: AcquireProfilingLockInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAcquireProfilingLockInfoKHR {} impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> { type Target = AcquireProfilingLockInfoKHR; fn deref(&self) -> &Self::Target { @@ -37041,20 +35419,6 @@ impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> { self.inner.timeout = timeout; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37149,7 +35513,6 @@ pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> { inner: HeadlessSurfaceCreateInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsHeadlessSurfaceCreateInfoEXT {} impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> { type Target = HeadlessSurfaceCreateInfoEXT; fn deref(&self) -> &Self::Target { @@ -37166,20 +35529,6 @@ impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> { self.inner.flags = flags; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37217,6 +35566,11 @@ pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { inner: PhysicalDeviceCoverageReductionModeFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { @@ -37348,7 +35702,6 @@ pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> { inner: FramebufferMixedSamplesCombinationNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsFramebufferMixedSamplesCombinationNV {} impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> { type Target = FramebufferMixedSamplesCombinationNV; fn deref(&self) -> &Self::Target { @@ -37380,23 +35733,6 @@ impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> { self.inner.color_samples = color_samples; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37434,6 +35770,11 @@ pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> { @@ -37562,7 +35903,6 @@ pub struct InitializePerformanceApiInfoINTELBuilder<'a> { inner: InitializePerformanceApiInfoINTEL, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsInitializePerformanceApiInfoINTEL {} impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> { type Target = InitializePerformanceApiInfoINTEL; fn deref(&self) -> &Self::Target { @@ -37579,23 +35919,6 @@ impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> { self.inner.p_user_data = user_data; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37691,7 +36014,6 @@ pub struct PerformanceMarkerInfoINTELBuilder<'a> { inner: PerformanceMarkerInfoINTEL, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPerformanceMarkerInfoINTEL {} impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> { type Target = PerformanceMarkerInfoINTEL; fn deref(&self) -> &Self::Target { @@ -37708,20 +36030,6 @@ impl<'a> PerformanceMarkerInfoINTELBuilder<'a> { self.inner.marker = marker; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37759,7 +36067,6 @@ pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> { inner: PerformanceStreamMarkerInfoINTEL, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPerformanceStreamMarkerInfoINTEL {} impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> { type Target = PerformanceStreamMarkerInfoINTEL; fn deref(&self) -> &Self::Target { @@ -37776,23 +36083,6 @@ impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> { self.inner.marker = marker; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37834,7 +36124,6 @@ pub struct PerformanceOverrideInfoINTELBuilder<'a> { inner: PerformanceOverrideInfoINTEL, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPerformanceOverrideInfoINTEL {} impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> { type Target = PerformanceOverrideInfoINTEL; fn deref(&self) -> &Self::Target { @@ -37859,20 +36148,6 @@ impl<'a> PerformanceOverrideInfoINTELBuilder<'a> { self.inner.parameter = parameter; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37910,7 +36185,6 @@ pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> { inner: PerformanceConfigurationAcquireInfoINTEL, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPerformanceConfigurationAcquireInfoINTEL {} impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> { type Target = PerformanceConfigurationAcquireInfoINTEL; fn deref(&self) -> &Self::Target { @@ -37927,23 +36201,6 @@ impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> { self.inner.ty = ty; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -37983,6 +36240,8 @@ pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { inner: PhysicalDeviceShaderClockFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { @@ -38042,6 +36301,8 @@ pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { inner: PhysicalDeviceIndexTypeUint8FeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { @@ -38161,6 +36422,8 @@ pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { @@ -38220,6 +36483,11 @@ pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> { @@ -38296,6 +36564,11 @@ pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> { @@ -38470,6 +36743,14 @@ pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR +{ +} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> { @@ -38528,7 +36809,6 @@ pub struct PipelineInfoKHRBuilder<'a> { inner: PipelineInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineInfoKHR {} impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> { type Target = PipelineInfoKHR; fn deref(&self) -> &Self::Target { @@ -38545,20 +36825,6 @@ impl<'a> PipelineInfoKHRBuilder<'a> { self.inner.pipeline = pipeline; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -38618,7 +36884,6 @@ pub struct PipelineExecutablePropertiesKHRBuilder<'a> { inner: PipelineExecutablePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineExecutablePropertiesKHR {} impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> { type Target = PipelineExecutablePropertiesKHR; fn deref(&self) -> &Self::Target { @@ -38647,20 +36912,6 @@ impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> { self.inner.subgroup_size = subgroup_size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -38700,7 +36951,6 @@ pub struct PipelineExecutableInfoKHRBuilder<'a> { inner: PipelineExecutableInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineExecutableInfoKHR {} impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> { type Target = PipelineExecutableInfoKHR; fn deref(&self) -> &Self::Target { @@ -38721,20 +36971,6 @@ impl<'a> PipelineExecutableInfoKHRBuilder<'a> { self.inner.executable_index = executable_index; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -38808,7 +37044,6 @@ pub struct PipelineExecutableStatisticKHRBuilder<'a> { inner: PipelineExecutableStatisticKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineExecutableStatisticKHR {} impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> { type Target = PipelineExecutableStatisticKHR; fn deref(&self) -> &Self::Target { @@ -38837,20 +37072,6 @@ impl<'a> PipelineExecutableStatisticKHRBuilder<'a> { self.inner.value = value; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -38913,7 +37134,6 @@ pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> { inner: PipelineExecutableInternalRepresentationKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineExecutableInternalRepresentationKHR {} impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> { type Target = PipelineExecutableInternalRepresentationKHR; fn deref(&self) -> &Self::Target { @@ -38943,23 +37163,6 @@ impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> { self.inner.p_data = data.as_mut_ptr() as *mut c_void; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -38997,6 +37200,14 @@ pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> { inner: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT +{ +} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'_> { @@ -39060,6 +37271,11 @@ pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { @@ -39211,6 +37427,11 @@ pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> { inner: PhysicalDeviceSubgroupSizeControlFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> { @@ -39465,7 +37686,6 @@ pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { inner: DeviceMemoryOpaqueCaptureAddressInfo, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDeviceMemoryOpaqueCaptureAddressInfo {} impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { type Target = DeviceMemoryOpaqueCaptureAddressInfo; fn deref(&self) -> &Self::Target { @@ -39482,23 +37702,6 @@ impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { self.inner.memory = memory; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -39546,6 +37749,11 @@ pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { inner: PhysicalDeviceLineRasterizationFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { @@ -39761,6 +37969,14 @@ pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> { inner: PhysicalDevicePipelineCreationCacheControlFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineCreationCacheControlFeaturesEXT +{ +} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'_> { @@ -39844,6 +38060,8 @@ pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> { inner: PhysicalDeviceVulkan11Features, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {} impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> { @@ -40194,6 +38412,8 @@ pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> { inner: PhysicalDeviceVulkan12Features, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {} impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> { @@ -41334,6 +39554,8 @@ pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { inner: PhysicalDeviceCoherentMemoryFeaturesAMD, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {} impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { @@ -41418,7 +39640,6 @@ pub struct PhysicalDeviceToolPropertiesEXTBuilder<'a> { inner: PhysicalDeviceToolPropertiesEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceToolPropertiesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesEXTBuilder<'a> { type Target = PhysicalDeviceToolPropertiesEXT; fn deref(&self) -> &Self::Target { @@ -41451,20 +39672,6 @@ impl<'a> PhysicalDeviceToolPropertiesEXTBuilder<'a> { self.inner.layer = layer; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -41636,6 +39843,11 @@ pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { inner: PhysicalDeviceCustomBorderColorFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { @@ -41749,7 +39961,6 @@ pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { inner: AccelerationStructureGeometryTrianglesDataKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { type Target = AccelerationStructureGeometryTrianglesDataKHR; fn deref(&self) -> &Self::Target { @@ -41790,23 +40001,6 @@ impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { self.inner.transform_data = transform_data; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -41856,7 +40050,6 @@ pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { inner: AccelerationStructureGeometryAabbsDataKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureGeometryAabbsDataKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { type Target = AccelerationStructureGeometryAabbsDataKHR; fn deref(&self) -> &Self::Target { @@ -41877,23 +40070,6 @@ impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { self.inner.stride = stride; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -41943,7 +40119,6 @@ pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { inner: AccelerationStructureGeometryInstancesDataKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureGeometryInstancesDataKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { type Target = AccelerationStructureGeometryInstancesDataKHR; fn deref(&self) -> &Self::Target { @@ -41964,23 +40139,6 @@ impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { self.inner.data = data; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42046,7 +40204,6 @@ pub struct AccelerationStructureGeometryKHRBuilder<'a> { inner: AccelerationStructureGeometryKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureGeometryKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> { type Target = AccelerationStructureGeometryKHR; fn deref(&self) -> &Self::Target { @@ -42071,23 +40228,6 @@ impl<'a> AccelerationStructureGeometryKHRBuilder<'a> { self.inner.flags = flags; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42164,7 +40304,6 @@ pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { inner: AccelerationStructureBuildGeometryInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureBuildGeometryInfoKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { type Target = AccelerationStructureBuildGeometryInfoKHR; fn deref(&self) -> &Self::Target { @@ -42220,23 +40359,6 @@ impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { self.inner.scratch_data = scratch_data; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42341,7 +40463,6 @@ pub struct AccelerationStructureCreateInfoKHRBuilder<'a> { inner: AccelerationStructureCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> { type Target = AccelerationStructureCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -42378,23 +40499,6 @@ impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> { self.inner.device_address = device_address; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42518,7 +40622,6 @@ pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { inner: AccelerationStructureDeviceAddressInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureDeviceAddressInfoKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { type Target = AccelerationStructureDeviceAddressInfoKHR; fn deref(&self) -> &Self::Target { @@ -42538,23 +40641,6 @@ impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { self.inner.acceleration_structure = acceleration_structure; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42592,7 +40678,6 @@ pub struct AccelerationStructureVersionInfoKHRBuilder<'a> { inner: AccelerationStructureVersionInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureVersionInfoKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> { type Target = AccelerationStructureVersionInfoKHR; fn deref(&self) -> &Self::Target { @@ -42609,23 +40694,6 @@ impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> { self.inner.p_version_data = version_data.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42667,7 +40735,6 @@ pub struct CopyAccelerationStructureInfoKHRBuilder<'a> { inner: CopyAccelerationStructureInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyAccelerationStructureInfoKHR {} impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> { type Target = CopyAccelerationStructureInfoKHR; fn deref(&self) -> &Self::Target { @@ -42692,23 +40759,6 @@ impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> { self.inner.mode = mode; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42761,7 +40811,6 @@ pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { inner: CopyAccelerationStructureToMemoryInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyAccelerationStructureToMemoryInfoKHR {} impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { type Target = CopyAccelerationStructureToMemoryInfoKHR; fn deref(&self) -> &Self::Target { @@ -42786,23 +40835,6 @@ impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { self.inner.mode = mode; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42855,7 +40887,6 @@ pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { inner: CopyMemoryToAccelerationStructureInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyMemoryToAccelerationStructureInfoKHR {} impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { type Target = CopyMemoryToAccelerationStructureInfoKHR; fn deref(&self) -> &Self::Target { @@ -42880,23 +40911,6 @@ impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { self.inner.mode = mode; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -42936,7 +40950,6 @@ pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { inner: RayTracingPipelineInterfaceCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsRayTracingPipelineInterfaceCreateInfoKHR {} impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { type Target = RayTracingPipelineInterfaceCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -42960,23 +40973,6 @@ impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -43016,7 +41012,6 @@ pub struct PipelineLibraryCreateInfoKHRBuilder<'a> { inner: PipelineLibraryCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPipelineLibraryCreateInfoKHR {} impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> { type Target = PipelineLibraryCreateInfoKHR; fn deref(&self) -> &Self::Target { @@ -43034,20 +41029,6 @@ impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> { self.inner.p_libraries = libraries.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -43085,6 +41066,11 @@ pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { @@ -43319,6 +41305,11 @@ pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { inner: PhysicalDeviceDiagnosticsConfigFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {} impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { @@ -43429,6 +41420,14 @@ pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> { inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR +{ +} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'_> { @@ -43497,6 +41496,8 @@ pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { inner: PhysicalDeviceRobustness2FeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { @@ -43629,6 +41630,8 @@ pub struct PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { inner: PhysicalDeviceImageRobustnessFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { @@ -43690,6 +41693,14 @@ pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR +{ +} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> { @@ -43806,6 +41817,11 @@ pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { inner: PhysicalDevicePortabilitySubsetFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { @@ -43995,6 +42011,8 @@ pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { inner: PhysicalDevice4444FormatsFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { @@ -44058,7 +42076,6 @@ pub struct BufferCopy2KHRBuilder<'a> { inner: BufferCopy2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferCopy2KHR {} impl<'a> ::std::ops::Deref for BufferCopy2KHRBuilder<'a> { type Target = BufferCopy2KHR; fn deref(&self) -> &Self::Target { @@ -44083,20 +42100,6 @@ impl<'a> BufferCopy2KHRBuilder<'a> { self.inner.size = size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44142,7 +42145,6 @@ pub struct ImageCopy2KHRBuilder<'a> { inner: ImageCopy2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageCopy2KHR {} impl<'a> ::std::ops::Deref for ImageCopy2KHRBuilder<'a> { type Target = ImageCopy2KHR; fn deref(&self) -> &Self::Target { @@ -44175,20 +42177,6 @@ impl<'a> ImageCopy2KHRBuilder<'a> { self.inner.extent = extent; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44418,7 +42406,6 @@ pub struct ImageResolve2KHRBuilder<'a> { inner: ImageResolve2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsImageResolve2KHR {} impl<'a> ::std::ops::Deref for ImageResolve2KHRBuilder<'a> { type Target = ImageResolve2KHR; fn deref(&self) -> &Self::Target { @@ -44451,20 +42438,6 @@ impl<'a> ImageResolve2KHRBuilder<'a> { self.inner.extent = extent; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44508,7 +42481,6 @@ pub struct CopyBufferInfo2KHRBuilder<'a> { inner: CopyBufferInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyBufferInfo2KHR {} impl<'a> ::std::ops::Deref for CopyBufferInfo2KHRBuilder<'a> { type Target = CopyBufferInfo2KHR; fn deref(&self) -> &Self::Target { @@ -44534,20 +42506,6 @@ impl<'a> CopyBufferInfo2KHRBuilder<'a> { self.inner.p_regions = regions.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44595,7 +42553,6 @@ pub struct CopyImageInfo2KHRBuilder<'a> { inner: CopyImageInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyImageInfo2KHR {} impl<'a> ::std::ops::Deref for CopyImageInfo2KHRBuilder<'a> { type Target = CopyImageInfo2KHR; fn deref(&self) -> &Self::Target { @@ -44629,20 +42586,6 @@ impl<'a> CopyImageInfo2KHRBuilder<'a> { self.inner.p_regions = regions.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44692,7 +42635,6 @@ pub struct BlitImageInfo2KHRBuilder<'a> { inner: BlitImageInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBlitImageInfo2KHR {} impl<'a> ::std::ops::Deref for BlitImageInfo2KHRBuilder<'a> { type Target = BlitImageInfo2KHR; fn deref(&self) -> &Self::Target { @@ -44730,20 +42672,6 @@ impl<'a> BlitImageInfo2KHRBuilder<'a> { self.inner.filter = filter; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44789,7 +42717,6 @@ pub struct CopyBufferToImageInfo2KHRBuilder<'a> { inner: CopyBufferToImageInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyBufferToImageInfo2KHR {} impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2KHRBuilder<'a> { type Target = CopyBufferToImageInfo2KHR; fn deref(&self) -> &Self::Target { @@ -44819,20 +42746,6 @@ impl<'a> CopyBufferToImageInfo2KHRBuilder<'a> { self.inner.p_regions = regions.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44878,7 +42791,6 @@ pub struct CopyImageToBufferInfo2KHRBuilder<'a> { inner: CopyImageToBufferInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCopyImageToBufferInfo2KHR {} impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2KHRBuilder<'a> { type Target = CopyImageToBufferInfo2KHR; fn deref(&self) -> &Self::Target { @@ -44908,20 +42820,6 @@ impl<'a> CopyImageToBufferInfo2KHRBuilder<'a> { self.inner.p_regions = regions.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -44969,7 +42867,6 @@ pub struct ResolveImageInfo2KHRBuilder<'a> { inner: ResolveImageInfo2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsResolveImageInfo2KHR {} impl<'a> ::std::ops::Deref for ResolveImageInfo2KHRBuilder<'a> { type Target = ResolveImageInfo2KHR; fn deref(&self) -> &Self::Target { @@ -45003,20 +42900,6 @@ impl<'a> ResolveImageInfo2KHRBuilder<'a> { self.inner.p_regions = regions.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -45056,6 +42939,11 @@ pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { @@ -45250,6 +43138,11 @@ pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { inner: PhysicalDeviceFragmentShadingRateFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { @@ -45540,7 +43433,6 @@ pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { inner: PhysicalDeviceFragmentShadingRateKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceFragmentShadingRateKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { type Target = PhysicalDeviceFragmentShadingRateKHR; fn deref(&self) -> &Self::Target { @@ -45561,23 +43453,6 @@ impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { self.inner.fragment_size = fragment_size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -45615,6 +43490,11 @@ pub struct PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> { inner: PhysicalDeviceShaderTerminateInvocationFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'_> { @@ -45677,6 +43557,11 @@ pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> { @@ -45889,7 +43774,6 @@ pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> { inner: AccelerationStructureBuildSizesInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureBuildSizesInfoKHR {} impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { type Target = AccelerationStructureBuildSizesInfoKHR; fn deref(&self) -> &Self::Target { @@ -45914,23 +43798,6 @@ impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { self.inner.build_scratch_size = build_scratch_size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -45968,6 +43835,11 @@ pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_> { @@ -46144,6 +44016,11 @@ pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> { @@ -46208,7 +44085,6 @@ pub struct VertexInputBindingDescription2EXTBuilder<'a> { inner: VertexInputBindingDescription2EXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVertexInputBindingDescription2EXT {} impl<'a> ::std::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> { type Target = VertexInputBindingDescription2EXT; fn deref(&self) -> &Self::Target { @@ -46237,23 +44113,6 @@ impl<'a> VertexInputBindingDescription2EXTBuilder<'a> { self.inner.divisor = divisor; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -46297,7 +44156,6 @@ pub struct VertexInputAttributeDescription2EXTBuilder<'a> { inner: VertexInputAttributeDescription2EXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVertexInputAttributeDescription2EXT {} impl<'a> ::std::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> { type Target = VertexInputAttributeDescription2EXT; fn deref(&self) -> &Self::Target { @@ -46326,23 +44184,6 @@ impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> { self.inner.offset = offset; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -46380,6 +44221,11 @@ pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { inner: PhysicalDeviceColorWriteEnableFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { @@ -46707,7 +44553,6 @@ pub struct BufferMemoryBarrier2KHRBuilder<'a> { inner: BufferMemoryBarrier2KHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBufferMemoryBarrier2KHR {} impl<'a> ::std::ops::Deref for BufferMemoryBarrier2KHRBuilder<'a> { type Target = BufferMemoryBarrier2KHR; fn deref(&self) -> &Self::Target { @@ -46756,20 +44601,6 @@ impl<'a> BufferMemoryBarrier2KHRBuilder<'a> { self.inner.size = size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -46819,7 +44650,6 @@ pub struct DependencyInfoKHRBuilder<'a> { inner: DependencyInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsDependencyInfoKHR {} impl<'a> ::std::ops::Deref for DependencyInfoKHRBuilder<'a> { type Target = DependencyInfoKHR; fn deref(&self) -> &Self::Target { @@ -46857,20 +44687,6 @@ impl<'a> DependencyInfoKHRBuilder<'a> { self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -46914,7 +44730,6 @@ pub struct SemaphoreSubmitInfoKHRBuilder<'a> { inner: SemaphoreSubmitInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsSemaphoreSubmitInfoKHR {} impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoKHRBuilder<'a> { type Target = SemaphoreSubmitInfoKHR; fn deref(&self) -> &Self::Target { @@ -46943,20 +44758,6 @@ impl<'a> SemaphoreSubmitInfoKHRBuilder<'a> { self.inner.device_index = device_index; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -46996,7 +44797,6 @@ pub struct CommandBufferSubmitInfoKHRBuilder<'a> { inner: CommandBufferSubmitInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCommandBufferSubmitInfoKHR {} impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoKHRBuilder<'a> { type Target = CommandBufferSubmitInfoKHR; fn deref(&self) -> &Self::Target { @@ -47017,20 +44817,6 @@ impl<'a> CommandBufferSubmitInfoKHRBuilder<'a> { self.inner.device_mask = device_mask; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -47232,7 +45018,6 @@ pub struct CheckpointData2NVBuilder<'a> { inner: CheckpointData2NV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsCheckpointData2NV {} impl<'a> ::std::ops::Deref for CheckpointData2NVBuilder<'a> { type Target = CheckpointData2NV; fn deref(&self) -> &Self::Target { @@ -47253,20 +45038,6 @@ impl<'a> CheckpointData2NVBuilder<'a> { self.inner.p_checkpoint_marker = checkpoint_marker; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -47304,6 +45075,11 @@ pub struct PhysicalDeviceSynchronization2FeaturesKHRBuilder<'a> { inner: PhysicalDeviceSynchronization2FeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSynchronization2FeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesKHR {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesKHRBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesKHRBuilder<'a> { @@ -47486,7 +45262,6 @@ pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { inner: PhysicalDeviceVideoFormatInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsPhysicalDeviceVideoFormatInfoKHR {} impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { type Target = PhysicalDeviceVideoFormatInfoKHR; fn deref(&self) -> &Self::Target { @@ -47507,23 +45282,6 @@ impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { self.inner.p_video_profiles = video_profiles; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -47561,7 +45319,6 @@ pub struct VideoFormatPropertiesKHRBuilder<'a> { inner: VideoFormatPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoFormatPropertiesKHR {} impl<'a> ::std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> { type Target = VideoFormatPropertiesKHR; fn deref(&self) -> &Self::Target { @@ -47578,20 +45335,6 @@ impl<'a> VideoFormatPropertiesKHRBuilder<'a> { self.inner.format = format; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -47645,6 +45388,7 @@ unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHRBuilder<'_> {} unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHR {} unsafe impl ExtendsBufferCreateInfo for VideoProfileKHRBuilder<'_> {} unsafe impl ExtendsBufferCreateInfo for VideoProfileKHR {} +pub unsafe trait ExtendsVideoProfileKHR {} impl<'a> ::std::ops::Deref for VideoProfileKHRBuilder<'a> { type Target = VideoProfileKHR; fn deref(&self) -> &Self::Target { @@ -47679,6 +45423,20 @@ impl<'a> VideoProfileKHRBuilder<'a> { self.inner.chroma_bit_depth = chroma_bit_depth; self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = 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 + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -47843,7 +45601,6 @@ pub struct VideoGetMemoryPropertiesKHRBuilder<'a> { inner: VideoGetMemoryPropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoGetMemoryPropertiesKHR {} impl<'a> ::std::ops::Deref for VideoGetMemoryPropertiesKHRBuilder<'a> { type Target = VideoGetMemoryPropertiesKHR; fn deref(&self) -> &Self::Target { @@ -47864,20 +45621,6 @@ impl<'a> VideoGetMemoryPropertiesKHRBuilder<'a> { self.inner.p_memory_requirements = memory_requirements; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -47921,7 +45664,6 @@ pub struct VideoBindMemoryKHRBuilder<'a> { inner: VideoBindMemoryKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoBindMemoryKHR {} impl<'a> ::std::ops::Deref for VideoBindMemoryKHRBuilder<'a> { type Target = VideoBindMemoryKHR; fn deref(&self) -> &Self::Target { @@ -47950,20 +45692,6 @@ impl<'a> VideoBindMemoryKHRBuilder<'a> { self.inner.memory_size = memory_size; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -48007,7 +45735,6 @@ pub struct VideoPictureResourceKHRBuilder<'a> { inner: VideoPictureResourceKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoPictureResourceKHR {} impl<'a> ::std::ops::Deref for VideoPictureResourceKHRBuilder<'a> { type Target = VideoPictureResourceKHR; fn deref(&self) -> &Self::Target { @@ -48036,20 +45763,6 @@ impl<'a> VideoPictureResourceKHRBuilder<'a> { self.inner.image_view_binding = image_view_binding; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -48282,7 +45995,8 @@ pub struct VideoDecodeH264ProfileEXTBuilder<'a> { inner: VideoDecodeH264ProfileEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoDecodeH264ProfileEXT {} +unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileEXTBuilder<'a> { type Target = VideoDecodeH264ProfileEXT; fn deref(&self) -> &Self::Target { @@ -48303,20 +46017,6 @@ impl<'a> VideoDecodeH264ProfileEXTBuilder<'a> { self.inner.field_layout = field_layout; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -48637,6 +46337,7 @@ pub struct VideoDecodeH264PictureInfoEXTBuilder<'a> { } unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXTBuilder<'_> {} unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT {} +pub unsafe trait ExtendsVideoDecodeH264PictureInfoEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoEXTBuilder<'a> { type Target = VideoDecodeH264PictureInfoEXT; fn deref(&self) -> &Self::Target { @@ -48658,6 +46359,20 @@ impl<'a> VideoDecodeH264PictureInfoEXTBuilder<'a> { self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr(); self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = 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 + } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -48753,7 +46468,8 @@ pub struct VideoDecodeH264MvcEXTBuilder<'a> { inner: VideoDecodeH264MvcEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoDecodeH264MvcEXT {} +unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXTBuilder<'_> {} +unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH264MvcEXTBuilder<'a> { type Target = VideoDecodeH264MvcEXT; fn deref(&self) -> &Self::Target { @@ -48770,20 +46486,6 @@ impl<'a> VideoDecodeH264MvcEXTBuilder<'a> { self.inner.p_std_mvc = std_mvc; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -48821,7 +46523,8 @@ pub struct VideoDecodeH265ProfileEXTBuilder<'a> { inner: VideoDecodeH265ProfileEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoDecodeH265ProfileEXT {} +unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileEXTBuilder<'a> { type Target = VideoDecodeH265ProfileEXT; fn deref(&self) -> &Self::Target { @@ -48838,20 +46541,6 @@ impl<'a> VideoDecodeH265ProfileEXTBuilder<'a> { self.inner.std_profile_idc = std_profile_idc; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -49562,7 +47251,6 @@ pub struct VideoBeginCodingInfoKHRBuilder<'a> { inner: VideoBeginCodingInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoBeginCodingInfoKHR {} impl<'a> ::std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> { type Target = VideoBeginCodingInfoKHR; fn deref(&self) -> &Self::Target { @@ -49602,20 +47290,6 @@ impl<'a> VideoBeginCodingInfoKHRBuilder<'a> { self.inner.p_reference_slots = reference_slots.as_ptr(); self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -49653,7 +47327,6 @@ pub struct VideoEndCodingInfoKHRBuilder<'a> { inner: VideoEndCodingInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoEndCodingInfoKHR {} impl<'a> ::std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> { type Target = VideoEndCodingInfoKHR; fn deref(&self) -> &Self::Target { @@ -49670,20 +47343,6 @@ impl<'a> VideoEndCodingInfoKHRBuilder<'a> { self.inner.flags = flags; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -50341,7 +48000,6 @@ pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { inner: VideoEncodeH264DpbSlotInfoEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoEncodeH264DpbSlotInfoEXT {} impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { type Target = VideoEncodeH264DpbSlotInfoEXT; fn deref(&self) -> &Self::Target { @@ -50362,20 +48020,6 @@ impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { self.inner.p_std_picture_info = std_picture_info; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -50577,7 +48221,8 @@ pub struct VideoEncodeH264ProfileEXTBuilder<'a> { inner: VideoEncodeH264ProfileEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoEncodeH264ProfileEXT {} +unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT {} impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileEXTBuilder<'a> { type Target = VideoEncodeH264ProfileEXT; fn deref(&self) -> &Self::Target { @@ -50594,20 +48239,6 @@ impl<'a> VideoEncodeH264ProfileEXTBuilder<'a> { self.inner.std_profile_idc = std_profile_idc; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -50661,7 +48292,6 @@ pub struct VideoEncodeH264NaluSliceEXTBuilder<'a> { inner: VideoEncodeH264NaluSliceEXT, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsVideoEncodeH264NaluSliceEXT {} impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceEXTBuilder<'a> { type Target = VideoEncodeH264NaluSliceEXT; fn deref(&self) -> &Self::Target { @@ -50710,20 +48340,6 @@ impl<'a> VideoEncodeH264NaluSliceEXTBuilder<'a> { self.inner.max_qp = max_qp; self } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next(mut self, next: &'a mut T) -> Self { - unsafe { - let next_ptr = 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 - } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] @@ -50761,6 +48377,11 @@ pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { inner: PhysicalDeviceInheritedViewportScissorFeaturesNV, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> { @@ -50889,6 +48510,11 @@ pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, marker: ::std::marker::PhantomData<&'a ()>, } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> {} unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { diff --git a/generator/src/lib.rs b/generator/src/lib.rs index c33722a14..cc0d1adae 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1778,7 +1778,7 @@ pub fn derive_debug( pub fn derive_setters( _struct: &vkxml::Struct, - root_struct_names: &HashSet, + root_structs: &HashSet, ) -> Option { if &_struct.name == "VkBaseInStructure" || &_struct.name == "VkBaseOutStructure" @@ -1979,19 +1979,7 @@ pub fn derive_setters( let extends_name = format_ident!("Extends{}", name); - let root_structs: Vec = _struct - .extends - .as_ref() - .map(|extends| { - extends - .split(',') - .filter(|extend| root_struct_names.contains(*extend)) - .map(|extends| format_ident!("Extends{}", name_to_tokens(extends))) - .collect() - }) - .unwrap_or_else(Vec::new); - - let is_root_struct = has_next && root_structs.is_empty(); + let is_root_struct = has_next && root_structs.contains(&name); // We only implement a next methods for root structs with a `pnext` field. let next_function = if is_root_struct { @@ -2032,13 +2020,18 @@ pub fn derive_setters( quote!() }; - // 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<'_> {} - unsafe impl #extends for #name {} - } - }); + // If the struct extends something we need to implement the traits. + let impl_extend_trait = _struct + .extends + .iter() + .flat_map(|extends| extends.split(',')) + .map(|extends| format_ident!("Extends{}", name_to_tokens(extends))) + .map(|extends| { + quote! { + unsafe impl #extends for #name_builder<'_> {} + unsafe impl #extends for #name {} + } + }); let q = quote! { impl #name { @@ -2104,7 +2097,7 @@ pub fn manual_derives(_struct: &vkxml::Struct) -> TokenStream { } pub fn generate_struct( _struct: &vkxml::Struct, - root_struct_names: &HashSet, + root_structs: &HashSet, union_types: &HashSet<&str, impl BuildHasher>, ) -> TokenStream { let name = name_to_tokens(&_struct.name); @@ -2150,7 +2143,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_struct_names); + let setter_tokens = derive_setters(_struct, root_structs); let manual_derive_tokens = manual_derives(_struct); let dbg_str = if debug_tokens.is_none() { quote!(Debug,) @@ -2248,26 +2241,23 @@ fn generate_union(union: &vkxml::Union) -> TokenStream { } } } -pub fn root_struct_names(definitions: &[&vkxml::DefinitionsElement]) -> HashSet { - definitions - .iter() - .filter_map(|definition| match *definition { - vkxml::DefinitionsElement::Struct(ref _struct) => { - let is_root_struct = _struct.extends.is_none(); - if is_root_struct { - Some(_struct.name.clone()) - } else { - None - } +/// Root structs are all structs that are extended by other structs. +pub fn root_structs(definitions: &[&vkxml::DefinitionsElement]) -> HashSet { + let mut root_structs = HashSet::new(); + // Loop over all structs and collect their extends + for definition in definitions { + if let vkxml::DefinitionsElement::Struct(ref _struct) = definition { + if let Some(extends) = &_struct.extends { + root_structs.extend(extends.split(',').map(name_to_tokens)); } - _ => None, - }) - .collect() + }; + } + root_structs } pub fn generate_definition( definition: &vkxml::DefinitionsElement, union_types: &HashSet<&str, impl BuildHasher>, - root_structs: &HashSet, + root_structs: &HashSet, bitflags_cache: &mut HashSet, const_values: &mut BTreeMap, identifier_renames: &mut BTreeMap, @@ -2731,14 +2721,14 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { let mut identifier_renames = BTreeMap::new(); - let root_names = root_struct_names(&definitions); + let root_structs = root_structs(&definitions); let definition_code: Vec<_> = definitions .into_iter() .filter_map(|def| { generate_definition( def, &union_types, - &root_names, + &root_structs, &mut bitflags_cache, &mut const_values, &mut identifier_renames,