ash/vk/
definitions.rs

1use crate::vk::aliases::*;
2use crate::vk::bitflags::*;
3use crate::vk::constants::*;
4use crate::vk::enums::*;
5use crate::vk::native::*;
6use crate::vk::platform_types::*;
7use crate::vk::prelude::*;
8use crate::vk::{ptr_chain_iter, Handle};
9use std::fmt;
10use std::os::raw::*;
11#[deprecated = "This define is deprecated. VK_MAKE_API_VERSION should be used instead."]
12#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_VERSION.html>"]
13pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 {
14    ((major) << 22) | ((minor) << 12) | (patch)
15}
16#[deprecated = "This define is deprecated. VK_API_VERSION_MAJOR should be used instead."]
17#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MAJOR.html>"]
18pub const fn version_major(version: u32) -> u32 {
19    (version) >> 22
20}
21#[deprecated = "This define is deprecated. VK_API_VERSION_MINOR should be used instead."]
22#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MINOR.html>"]
23pub const fn version_minor(version: u32) -> u32 {
24    ((version) >> 12) & 0x3ffu32
25}
26#[deprecated = "This define is deprecated. VK_API_VERSION_PATCH should be used instead."]
27#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_PATCH.html>"]
28pub const fn version_patch(version: u32) -> u32 {
29    (version) & 0xfffu32
30}
31#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_API_VERSION.html>"]
32pub const fn make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
33    ((variant) << 29) | ((major) << 22) | ((minor) << 12) | (patch)
34}
35#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_VARIANT.html>"]
36pub const fn api_version_variant(version: u32) -> u32 {
37    (version) >> 29
38}
39#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MAJOR.html>"]
40pub const fn api_version_major(version: u32) -> u32 {
41    ((version) >> 22) & 0x7fu32
42}
43#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MINOR.html>"]
44pub const fn api_version_minor(version: u32) -> u32 {
45    ((version) >> 12) & 0x3ffu32
46}
47#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_PATCH.html>"]
48pub const fn api_version_patch(version: u32) -> u32 {
49    (version) & 0xfffu32
50}
51#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_0.html>"]
52pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0);
53#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_1.html>"]
54pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0);
55#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_2.html>"]
56pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0);
57#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_3.html>"]
58pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0);
59pub const HEADER_VERSION: u32 = 209u32;
60#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
61pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION);
62#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleMask.html>"]
63pub type SampleMask = u32;
64#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBool32.html>"]
65pub type Bool32 = u32;
66#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags.html>"]
67pub type Flags = u32;
68#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags64.html>"]
69pub type Flags64 = u64;
70#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceSize.html>"]
71pub type DeviceSize = u64;
72#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddress.html>"]
73pub type DeviceAddress = u64;
74#[repr(transparent)]
75#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
76#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateFlags.html>"]
77pub struct QueryPoolCreateFlags(pub(crate) Flags);
78vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags);
79#[repr(transparent)]
80#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
81#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
82pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags);
83vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags);
84#[repr(transparent)]
85#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
86#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
87pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags);
88vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags);
89#[repr(transparent)]
90#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
91#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
92pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags);
93vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, Flags);
94#[repr(transparent)]
95#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
96#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
97pub struct PipelineViewportStateCreateFlags(pub(crate) Flags);
98vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, Flags);
99#[repr(transparent)]
100#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
101#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
102pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags);
103vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, Flags);
104#[repr(transparent)]
105#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
106#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
107pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags);
108vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, Flags);
109#[repr(transparent)]
110#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
111#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
112pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags);
113vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, Flags);
114#[repr(transparent)]
115#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
116#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateFlags.html>"]
117pub struct BufferViewCreateFlags(pub(crate) Flags);
118vk_bitflags_wrapped!(BufferViewCreateFlags, Flags);
119#[repr(transparent)]
120#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
121#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateFlags.html>"]
122pub struct DeviceCreateFlags(pub(crate) Flags);
123vk_bitflags_wrapped!(DeviceCreateFlags, Flags);
124#[repr(transparent)]
125#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
126#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapFlags.html>"]
127pub struct MemoryMapFlags(pub(crate) Flags);
128vk_bitflags_wrapped!(MemoryMapFlags, Flags);
129#[repr(transparent)]
130#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
131#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
132pub struct DescriptorPoolResetFlags(pub(crate) Flags);
133vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags);
134#[repr(transparent)]
135#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
136#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
137pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags);
138vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, Flags);
139#[repr(transparent)]
140#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
141#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>"]
142pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags);
143vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags);
144#[repr(transparent)]
145#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
146#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>"]
147pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags);
148vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags);
149#[repr(transparent)]
150#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
151#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
152pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags);
153vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags);
154#[repr(transparent)]
155#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
156#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
157pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags);
158vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, Flags);
159#[repr(transparent)]
160#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
161#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
162pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags);
163vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, Flags);
164#[repr(transparent)]
165#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
166#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
167pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags);
168vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, Flags);
169#[repr(transparent)]
170#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
171#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
172pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags);
173vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, Flags);
174#[repr(transparent)]
175#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
176#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
177pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags);
178vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, Flags);
179#[repr(transparent)]
180#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
181#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
182pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags);
183vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, Flags);
184#[repr(transparent)]
185#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
186#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
187pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags);
188vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags);
189#[repr(transparent)]
190#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
191#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"]
192pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags);
193vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, Flags);
194#[repr(transparent)]
195#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
196#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
197pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags);
198vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, Flags);
199#[repr(transparent)]
200#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
201#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
202pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags);
203vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, Flags);
204#[repr(transparent)]
205#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
206#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
207pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags);
208vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, Flags);
209#[repr(transparent)]
210#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
211#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
212pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags);
213vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, Flags);
214#[repr(transparent)]
215#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
216#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
217pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags);
218vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, Flags);
219#[repr(transparent)]
220#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
221#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
222pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags);
223vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, Flags);
224#[repr(transparent)]
225#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
226#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateFlagsQNX.html>"]
227pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags);
228vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, Flags);
229#[repr(transparent)]
230#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
231#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolTrimFlags.html>"]
232pub struct CommandPoolTrimFlags(pub(crate) Flags);
233vk_bitflags_wrapped!(CommandPoolTrimFlags, Flags);
234#[repr(transparent)]
235#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
236#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
237pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags);
238vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, Flags);
239#[repr(transparent)]
240#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
241#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
242pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags);
243vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, Flags);
244#[repr(transparent)]
245#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
246#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
247pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags);
248vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, Flags);
249#[repr(transparent)]
250#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
251#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
252pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags);
253vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, Flags);
254#[repr(transparent)]
255#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
256#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
257pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags);
258vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, Flags);
259#[repr(transparent)]
260#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
261#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
262pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags);
263vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, Flags);
264#[repr(transparent)]
265#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
266#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
267pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags);
268vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, Flags);
269#[repr(transparent)]
270#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
271#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
272pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags);
273vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, Flags);
274#[repr(transparent)]
275#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
276#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"]
277pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags);
278vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, Flags);
279#[repr(transparent)]
280#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
281#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
282pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags);
283vk_bitflags_wrapped!(PipelineRasterizationConservativeStateCreateFlagsEXT, Flags);
284#[repr(transparent)]
285#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
286#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
287pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags);
288vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, Flags);
289#[repr(transparent)]
290#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
292pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags);
293vk_bitflags_wrapped!(PipelineRasterizationDepthClipStateCreateFlagsEXT, Flags);
294#[repr(transparent)]
295#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
296#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingFlagsKHR.html>"]
297pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags);
298vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags);
299#[repr(transparent)]
300#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
301#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingFlagsKHR.html>"]
302pub struct VideoEndCodingFlagsKHR(pub(crate) Flags);
303vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags);
304define_handle!(
305    Instance,
306    INSTANCE,
307    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html>"
308);
309define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice.html>") ;
310define_handle!(
311    Device,
312    DEVICE,
313    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevice.html>"
314);
315define_handle!(
316    Queue,
317    QUEUE,
318    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueue.html>"
319);
320define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBuffer.html>") ;
321handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemory.html>") ;
322handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPool.html>") ;
323handle_nondispatchable!(
324    Buffer,
325    BUFFER,
326    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuffer.html>"
327);
328handle_nondispatchable!(
329    BufferView,
330    BUFFER_VIEW,
331    doc =
332        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferView.html>"
333);
334handle_nondispatchable!(
335    Image,
336    IMAGE,
337    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImage.html>"
338);
339handle_nondispatchable!(
340    ImageView,
341    IMAGE_VIEW,
342    doc =
343        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageView.html>"
344);
345handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModule.html>") ;
346handle_nondispatchable!(
347    Pipeline,
348    PIPELINE,
349    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipeline.html>"
350);
351handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayout.html>") ;
352handle_nondispatchable!(
353    Sampler,
354    SAMPLER,
355    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampler.html>"
356);
357handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSet.html>") ;
358handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayout.html>") ;
359handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPool.html>") ;
360handle_nondispatchable!(
361    Fence,
362    FENCE,
363    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFence.html>"
364);
365handle_nondispatchable!(
366    Semaphore,
367    SEMAPHORE,
368    doc =
369        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphore.html>"
370);
371handle_nondispatchable!(
372    Event,
373    EVENT,
374    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEvent.html>"
375);
376handle_nondispatchable!(
377    QueryPool,
378    QUERY_POOL,
379    doc =
380        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPool.html>"
381);
382handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebuffer.html>") ;
383handle_nondispatchable!(
384    RenderPass,
385    RENDER_PASS,
386    doc =
387        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPass.html>"
388);
389handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCache.html>") ;
390handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutNV.html>") ;
391handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplate.html>") ;
392handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversion.html>") ;
393handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheEXT.html>") ;
394handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureKHR.html>") ;
395handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureNV.html>") ;
396handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationINTEL.html>") ;
397handle_nondispatchable ! (BufferCollectionFUCHSIA , BUFFER_COLLECTION_FUCHSIA , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionFUCHSIA.html>") ;
398handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeferredOperationKHR.html>") ;
399handle_nondispatchable ! (PrivateDataSlot , PRIVATE_DATA_SLOT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlot.html>") ;
400handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleNVX.html>") ;
401handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionNVX.html>") ;
402handle_nondispatchable!(
403    DisplayKHR,
404    DISPLAY_KHR,
405    doc =
406        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayKHR.html>"
407);
408handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeKHR.html>") ;
409handle_nondispatchable!(
410    SurfaceKHR,
411    SURFACE_KHR,
412    doc =
413        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html>"
414);
415handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainKHR.html>") ;
416handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackEXT.html>") ;
417handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerEXT.html>") ;
418handle_nondispatchable ! (VideoSessionKHR , VIDEO_SESSION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionKHR.html>") ;
419handle_nondispatchable ! (VideoSessionParametersKHR , VIDEO_SESSION_PARAMETERS_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersKHR.html>") ;
420#[allow(non_camel_case_types)]
421#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalAllocationNotification.html>"]
422pub type PFN_vkInternalAllocationNotification = Option<
423    unsafe extern "system" fn(
424        p_user_data: *mut c_void,
425        size: usize,
426        allocation_type: InternalAllocationType,
427        allocation_scope: SystemAllocationScope,
428    ),
429>;
430#[allow(non_camel_case_types)]
431#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalFreeNotification.html>"]
432pub type PFN_vkInternalFreeNotification = Option<
433    unsafe extern "system" fn(
434        p_user_data: *mut c_void,
435        size: usize,
436        allocation_type: InternalAllocationType,
437        allocation_scope: SystemAllocationScope,
438    ),
439>;
440#[allow(non_camel_case_types)]
441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkReallocationFunction.html>"]
442pub type PFN_vkReallocationFunction = Option<
443    unsafe extern "system" fn(
444        p_user_data: *mut c_void,
445        p_original: *mut c_void,
446        size: usize,
447        alignment: usize,
448        allocation_scope: SystemAllocationScope,
449    ) -> *mut c_void,
450>;
451#[allow(non_camel_case_types)]
452#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkAllocationFunction.html>"]
453pub type PFN_vkAllocationFunction = Option<
454    unsafe extern "system" fn(
455        p_user_data: *mut c_void,
456        size: usize,
457        alignment: usize,
458        allocation_scope: SystemAllocationScope,
459    ) -> *mut c_void,
460>;
461#[allow(non_camel_case_types)]
462#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkFreeFunction.html>"]
463pub type PFN_vkFreeFunction =
464    Option<unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void)>;
465#[allow(non_camel_case_types)]
466#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkVoidFunction.html>"]
467pub type PFN_vkVoidFunction = Option<unsafe extern "system" fn()>;
468#[allow(non_camel_case_types)]
469#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugReportCallbackEXT.html>"]
470pub type PFN_vkDebugReportCallbackEXT = Option<
471    unsafe extern "system" fn(
472        flags: DebugReportFlagsEXT,
473        object_type: DebugReportObjectTypeEXT,
474        object: u64,
475        location: usize,
476        message_code: i32,
477        p_layer_prefix: *const c_char,
478        p_message: *const c_char,
479        p_user_data: *mut c_void,
480    ) -> Bool32,
481>;
482#[allow(non_camel_case_types)]
483#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html>"]
484pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
485    unsafe extern "system" fn(
486        message_severity: DebugUtilsMessageSeverityFlagsEXT,
487        message_types: DebugUtilsMessageTypeFlagsEXT,
488        p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
489        p_user_data: *mut c_void,
490    ) -> Bool32,
491>;
492#[allow(non_camel_case_types)]
493#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDeviceMemoryReportCallbackEXT.html>"]
494pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<
495    unsafe extern "system" fn(
496        p_callback_data: *const DeviceMemoryReportCallbackDataEXT,
497        p_user_data: *mut c_void,
498    ),
499>;
500#[repr(C)]
501#[cfg_attr(feature = "debug", derive(Debug))]
502#[derive(Copy, Clone)]
503#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseOutStructure.html>"]
504pub struct BaseOutStructure {
505    pub s_type: StructureType,
506    pub p_next: *mut Self,
507}
508impl ::std::default::Default for BaseOutStructure {
509    fn default() -> Self {
510        Self {
511            s_type: unsafe { ::std::mem::zeroed() },
512            p_next: ::std::ptr::null_mut(),
513        }
514    }
515}
516#[repr(C)]
517#[cfg_attr(feature = "debug", derive(Debug))]
518#[derive(Copy, Clone)]
519#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseInStructure.html>"]
520pub struct BaseInStructure {
521    pub s_type: StructureType,
522    pub p_next: *const Self,
523}
524impl ::std::default::Default for BaseInStructure {
525    fn default() -> Self {
526        Self {
527            s_type: unsafe { ::std::mem::zeroed() },
528            p_next: ::std::ptr::null(),
529        }
530    }
531}
532#[repr(C)]
533#[cfg_attr(feature = "debug", derive(Debug))]
534#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
535#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset2D.html>"]
536pub struct Offset2D {
537    pub x: i32,
538    pub y: i32,
539}
540impl Offset2D {
541    pub fn builder<'a>() -> Offset2DBuilder<'a> {
542        Offset2DBuilder {
543            inner: Self::default(),
544            marker: ::std::marker::PhantomData,
545        }
546    }
547}
548#[repr(transparent)]
549pub struct Offset2DBuilder<'a> {
550    inner: Offset2D,
551    marker: ::std::marker::PhantomData<&'a ()>,
552}
553impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> {
554    type Target = Offset2D;
555    fn deref(&self) -> &Self::Target {
556        &self.inner
557    }
558}
559impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> {
560    fn deref_mut(&mut self) -> &mut Self::Target {
561        &mut self.inner
562    }
563}
564impl<'a> Offset2DBuilder<'a> {
565    pub fn x(mut self, x: i32) -> Self {
566        self.inner.x = x;
567        self
568    }
569    pub fn y(mut self, y: i32) -> Self {
570        self.inner.y = y;
571        self
572    }
573    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
574    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
575    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
576    pub fn build(self) -> Offset2D {
577        self.inner
578    }
579}
580#[repr(C)]
581#[cfg_attr(feature = "debug", derive(Debug))]
582#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
583#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset3D.html>"]
584pub struct Offset3D {
585    pub x: i32,
586    pub y: i32,
587    pub z: i32,
588}
589impl Offset3D {
590    pub fn builder<'a>() -> Offset3DBuilder<'a> {
591        Offset3DBuilder {
592            inner: Self::default(),
593            marker: ::std::marker::PhantomData,
594        }
595    }
596}
597#[repr(transparent)]
598pub struct Offset3DBuilder<'a> {
599    inner: Offset3D,
600    marker: ::std::marker::PhantomData<&'a ()>,
601}
602impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> {
603    type Target = Offset3D;
604    fn deref(&self) -> &Self::Target {
605        &self.inner
606    }
607}
608impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> {
609    fn deref_mut(&mut self) -> &mut Self::Target {
610        &mut self.inner
611    }
612}
613impl<'a> Offset3DBuilder<'a> {
614    pub fn x(mut self, x: i32) -> Self {
615        self.inner.x = x;
616        self
617    }
618    pub fn y(mut self, y: i32) -> Self {
619        self.inner.y = y;
620        self
621    }
622    pub fn z(mut self, z: i32) -> Self {
623        self.inner.z = z;
624        self
625    }
626    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
627    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
628    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
629    pub fn build(self) -> Offset3D {
630        self.inner
631    }
632}
633#[repr(C)]
634#[cfg_attr(feature = "debug", derive(Debug))]
635#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
636#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent2D.html>"]
637pub struct Extent2D {
638    pub width: u32,
639    pub height: u32,
640}
641impl Extent2D {
642    pub fn builder<'a>() -> Extent2DBuilder<'a> {
643        Extent2DBuilder {
644            inner: Self::default(),
645            marker: ::std::marker::PhantomData,
646        }
647    }
648}
649#[repr(transparent)]
650pub struct Extent2DBuilder<'a> {
651    inner: Extent2D,
652    marker: ::std::marker::PhantomData<&'a ()>,
653}
654impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> {
655    type Target = Extent2D;
656    fn deref(&self) -> &Self::Target {
657        &self.inner
658    }
659}
660impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> {
661    fn deref_mut(&mut self) -> &mut Self::Target {
662        &mut self.inner
663    }
664}
665impl<'a> Extent2DBuilder<'a> {
666    pub fn width(mut self, width: u32) -> Self {
667        self.inner.width = width;
668        self
669    }
670    pub fn height(mut self, height: u32) -> Self {
671        self.inner.height = height;
672        self
673    }
674    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
675    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
676    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
677    pub fn build(self) -> Extent2D {
678        self.inner
679    }
680}
681#[repr(C)]
682#[cfg_attr(feature = "debug", derive(Debug))]
683#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
684#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent3D.html>"]
685pub struct Extent3D {
686    pub width: u32,
687    pub height: u32,
688    pub depth: u32,
689}
690impl Extent3D {
691    pub fn builder<'a>() -> Extent3DBuilder<'a> {
692        Extent3DBuilder {
693            inner: Self::default(),
694            marker: ::std::marker::PhantomData,
695        }
696    }
697}
698#[repr(transparent)]
699pub struct Extent3DBuilder<'a> {
700    inner: Extent3D,
701    marker: ::std::marker::PhantomData<&'a ()>,
702}
703impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> {
704    type Target = Extent3D;
705    fn deref(&self) -> &Self::Target {
706        &self.inner
707    }
708}
709impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> {
710    fn deref_mut(&mut self) -> &mut Self::Target {
711        &mut self.inner
712    }
713}
714impl<'a> Extent3DBuilder<'a> {
715    pub fn width(mut self, width: u32) -> Self {
716        self.inner.width = width;
717        self
718    }
719    pub fn height(mut self, height: u32) -> Self {
720        self.inner.height = height;
721        self
722    }
723    pub fn depth(mut self, depth: u32) -> Self {
724        self.inner.depth = depth;
725        self
726    }
727    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
728    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
729    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
730    pub fn build(self) -> Extent3D {
731        self.inner
732    }
733}
734#[repr(C)]
735#[cfg_attr(feature = "debug", derive(Debug))]
736#[derive(Copy, Clone, Default)]
737#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewport.html>"]
738pub struct Viewport {
739    pub x: f32,
740    pub y: f32,
741    pub width: f32,
742    pub height: f32,
743    pub min_depth: f32,
744    pub max_depth: f32,
745}
746impl Viewport {
747    pub fn builder<'a>() -> ViewportBuilder<'a> {
748        ViewportBuilder {
749            inner: Self::default(),
750            marker: ::std::marker::PhantomData,
751        }
752    }
753}
754#[repr(transparent)]
755pub struct ViewportBuilder<'a> {
756    inner: Viewport,
757    marker: ::std::marker::PhantomData<&'a ()>,
758}
759impl<'a> ::std::ops::Deref for ViewportBuilder<'a> {
760    type Target = Viewport;
761    fn deref(&self) -> &Self::Target {
762        &self.inner
763    }
764}
765impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> {
766    fn deref_mut(&mut self) -> &mut Self::Target {
767        &mut self.inner
768    }
769}
770impl<'a> ViewportBuilder<'a> {
771    pub fn x(mut self, x: f32) -> Self {
772        self.inner.x = x;
773        self
774    }
775    pub fn y(mut self, y: f32) -> Self {
776        self.inner.y = y;
777        self
778    }
779    pub fn width(mut self, width: f32) -> Self {
780        self.inner.width = width;
781        self
782    }
783    pub fn height(mut self, height: f32) -> Self {
784        self.inner.height = height;
785        self
786    }
787    pub fn min_depth(mut self, min_depth: f32) -> Self {
788        self.inner.min_depth = min_depth;
789        self
790    }
791    pub fn max_depth(mut self, max_depth: f32) -> Self {
792        self.inner.max_depth = max_depth;
793        self
794    }
795    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
796    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
797    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
798    pub fn build(self) -> Viewport {
799        self.inner
800    }
801}
802#[repr(C)]
803#[cfg_attr(feature = "debug", derive(Debug))]
804#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
805#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRect2D.html>"]
806pub struct Rect2D {
807    pub offset: Offset2D,
808    pub extent: Extent2D,
809}
810impl Rect2D {
811    pub fn builder<'a>() -> Rect2DBuilder<'a> {
812        Rect2DBuilder {
813            inner: Self::default(),
814            marker: ::std::marker::PhantomData,
815        }
816    }
817}
818#[repr(transparent)]
819pub struct Rect2DBuilder<'a> {
820    inner: Rect2D,
821    marker: ::std::marker::PhantomData<&'a ()>,
822}
823impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> {
824    type Target = Rect2D;
825    fn deref(&self) -> &Self::Target {
826        &self.inner
827    }
828}
829impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> {
830    fn deref_mut(&mut self) -> &mut Self::Target {
831        &mut self.inner
832    }
833}
834impl<'a> Rect2DBuilder<'a> {
835    pub fn offset(mut self, offset: Offset2D) -> Self {
836        self.inner.offset = offset;
837        self
838    }
839    pub fn extent(mut self, extent: Extent2D) -> Self {
840        self.inner.extent = extent;
841        self
842    }
843    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
844    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
845    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
846    pub fn build(self) -> Rect2D {
847        self.inner
848    }
849}
850#[repr(C)]
851#[cfg_attr(feature = "debug", derive(Debug))]
852#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
853#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearRect.html>"]
854pub struct ClearRect {
855    pub rect: Rect2D,
856    pub base_array_layer: u32,
857    pub layer_count: u32,
858}
859impl ClearRect {
860    pub fn builder<'a>() -> ClearRectBuilder<'a> {
861        ClearRectBuilder {
862            inner: Self::default(),
863            marker: ::std::marker::PhantomData,
864        }
865    }
866}
867#[repr(transparent)]
868pub struct ClearRectBuilder<'a> {
869    inner: ClearRect,
870    marker: ::std::marker::PhantomData<&'a ()>,
871}
872impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> {
873    type Target = ClearRect;
874    fn deref(&self) -> &Self::Target {
875        &self.inner
876    }
877}
878impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> {
879    fn deref_mut(&mut self) -> &mut Self::Target {
880        &mut self.inner
881    }
882}
883impl<'a> ClearRectBuilder<'a> {
884    pub fn rect(mut self, rect: Rect2D) -> Self {
885        self.inner.rect = rect;
886        self
887    }
888    pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
889        self.inner.base_array_layer = base_array_layer;
890        self
891    }
892    pub fn layer_count(mut self, layer_count: u32) -> Self {
893        self.inner.layer_count = layer_count;
894        self
895    }
896    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
897    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
898    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
899    pub fn build(self) -> ClearRect {
900        self.inner
901    }
902}
903#[repr(C)]
904#[cfg_attr(feature = "debug", derive(Debug))]
905#[derive(Copy, Clone, Default)]
906#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComponentMapping.html>"]
907pub struct ComponentMapping {
908    pub r: ComponentSwizzle,
909    pub g: ComponentSwizzle,
910    pub b: ComponentSwizzle,
911    pub a: ComponentSwizzle,
912}
913impl ComponentMapping {
914    pub fn builder<'a>() -> ComponentMappingBuilder<'a> {
915        ComponentMappingBuilder {
916            inner: Self::default(),
917            marker: ::std::marker::PhantomData,
918        }
919    }
920}
921#[repr(transparent)]
922pub struct ComponentMappingBuilder<'a> {
923    inner: ComponentMapping,
924    marker: ::std::marker::PhantomData<&'a ()>,
925}
926impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> {
927    type Target = ComponentMapping;
928    fn deref(&self) -> &Self::Target {
929        &self.inner
930    }
931}
932impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> {
933    fn deref_mut(&mut self) -> &mut Self::Target {
934        &mut self.inner
935    }
936}
937impl<'a> ComponentMappingBuilder<'a> {
938    pub fn r(mut self, r: ComponentSwizzle) -> Self {
939        self.inner.r = r;
940        self
941    }
942    pub fn g(mut self, g: ComponentSwizzle) -> Self {
943        self.inner.g = g;
944        self
945    }
946    pub fn b(mut self, b: ComponentSwizzle) -> Self {
947        self.inner.b = b;
948        self
949    }
950    pub fn a(mut self, a: ComponentSwizzle) -> Self {
951        self.inner.a = a;
952        self
953    }
954    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
955    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
956    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
957    pub fn build(self) -> ComponentMapping {
958        self.inner
959    }
960}
961#[repr(C)]
962#[derive(Copy, Clone)]
963#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties.html>"]
964pub struct PhysicalDeviceProperties {
965    pub api_version: u32,
966    pub driver_version: u32,
967    pub vendor_id: u32,
968    pub device_id: u32,
969    pub device_type: PhysicalDeviceType,
970    pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE],
971    pub pipeline_cache_uuid: [u8; UUID_SIZE],
972    pub limits: PhysicalDeviceLimits,
973    pub sparse_properties: PhysicalDeviceSparseProperties,
974}
975#[cfg(feature = "debug")]
976impl fmt::Debug for PhysicalDeviceProperties {
977    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
978        fmt.debug_struct("PhysicalDeviceProperties")
979            .field("api_version", &self.api_version)
980            .field("driver_version", &self.driver_version)
981            .field("vendor_id", &self.vendor_id)
982            .field("device_id", &self.device_id)
983            .field("device_type", &self.device_type)
984            .field("device_name", &unsafe {
985                ::std::ffi::CStr::from_ptr(self.device_name.as_ptr())
986            })
987            .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
988            .field("limits", &self.limits)
989            .field("sparse_properties", &self.sparse_properties)
990            .finish()
991    }
992}
993impl ::std::default::Default for PhysicalDeviceProperties {
994    fn default() -> Self {
995        Self {
996            api_version: u32::default(),
997            driver_version: u32::default(),
998            vendor_id: u32::default(),
999            device_id: u32::default(),
1000            device_type: PhysicalDeviceType::default(),
1001            device_name: unsafe { ::std::mem::zeroed() },
1002            pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
1003            limits: PhysicalDeviceLimits::default(),
1004            sparse_properties: PhysicalDeviceSparseProperties::default(),
1005        }
1006    }
1007}
1008impl PhysicalDeviceProperties {
1009    pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> {
1010        PhysicalDevicePropertiesBuilder {
1011            inner: Self::default(),
1012            marker: ::std::marker::PhantomData,
1013        }
1014    }
1015}
1016#[repr(transparent)]
1017pub struct PhysicalDevicePropertiesBuilder<'a> {
1018    inner: PhysicalDeviceProperties,
1019    marker: ::std::marker::PhantomData<&'a ()>,
1020}
1021impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> {
1022    type Target = PhysicalDeviceProperties;
1023    fn deref(&self) -> &Self::Target {
1024        &self.inner
1025    }
1026}
1027impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> {
1028    fn deref_mut(&mut self) -> &mut Self::Target {
1029        &mut self.inner
1030    }
1031}
1032impl<'a> PhysicalDevicePropertiesBuilder<'a> {
1033    pub fn api_version(mut self, api_version: u32) -> Self {
1034        self.inner.api_version = api_version;
1035        self
1036    }
1037    pub fn driver_version(mut self, driver_version: u32) -> Self {
1038        self.inner.driver_version = driver_version;
1039        self
1040    }
1041    pub fn vendor_id(mut self, vendor_id: u32) -> Self {
1042        self.inner.vendor_id = vendor_id;
1043        self
1044    }
1045    pub fn device_id(mut self, device_id: u32) -> Self {
1046        self.inner.device_id = device_id;
1047        self
1048    }
1049    pub fn device_type(mut self, device_type: PhysicalDeviceType) -> Self {
1050        self.inner.device_type = device_type;
1051        self
1052    }
1053    pub fn device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self {
1054        self.inner.device_name = device_name;
1055        self
1056    }
1057    pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
1058        self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
1059        self
1060    }
1061    pub fn limits(mut self, limits: PhysicalDeviceLimits) -> Self {
1062        self.inner.limits = limits;
1063        self
1064    }
1065    pub fn sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self {
1066        self.inner.sparse_properties = sparse_properties;
1067        self
1068    }
1069    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1070    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1071    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1072    pub fn build(self) -> PhysicalDeviceProperties {
1073        self.inner
1074    }
1075}
1076#[repr(C)]
1077#[derive(Copy, Clone)]
1078#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtensionProperties.html>"]
1079pub struct ExtensionProperties {
1080    pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1081    pub spec_version: u32,
1082}
1083#[cfg(feature = "debug")]
1084impl fmt::Debug for ExtensionProperties {
1085    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1086        fmt.debug_struct("ExtensionProperties")
1087            .field("extension_name", &unsafe {
1088                ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr())
1089            })
1090            .field("spec_version", &self.spec_version)
1091            .finish()
1092    }
1093}
1094impl ::std::default::Default for ExtensionProperties {
1095    fn default() -> Self {
1096        Self {
1097            extension_name: unsafe { ::std::mem::zeroed() },
1098            spec_version: u32::default(),
1099        }
1100    }
1101}
1102impl ExtensionProperties {
1103    pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> {
1104        ExtensionPropertiesBuilder {
1105            inner: Self::default(),
1106            marker: ::std::marker::PhantomData,
1107        }
1108    }
1109}
1110#[repr(transparent)]
1111pub struct ExtensionPropertiesBuilder<'a> {
1112    inner: ExtensionProperties,
1113    marker: ::std::marker::PhantomData<&'a ()>,
1114}
1115impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> {
1116    type Target = ExtensionProperties;
1117    fn deref(&self) -> &Self::Target {
1118        &self.inner
1119    }
1120}
1121impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> {
1122    fn deref_mut(&mut self) -> &mut Self::Target {
1123        &mut self.inner
1124    }
1125}
1126impl<'a> ExtensionPropertiesBuilder<'a> {
1127    pub fn extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
1128        self.inner.extension_name = extension_name;
1129        self
1130    }
1131    pub fn spec_version(mut self, spec_version: u32) -> Self {
1132        self.inner.spec_version = spec_version;
1133        self
1134    }
1135    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1136    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1137    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1138    pub fn build(self) -> ExtensionProperties {
1139        self.inner
1140    }
1141}
1142#[repr(C)]
1143#[derive(Copy, Clone)]
1144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLayerProperties.html>"]
1145pub struct LayerProperties {
1146    pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1147    pub spec_version: u32,
1148    pub implementation_version: u32,
1149    pub description: [c_char; MAX_DESCRIPTION_SIZE],
1150}
1151#[cfg(feature = "debug")]
1152impl fmt::Debug for LayerProperties {
1153    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1154        fmt.debug_struct("LayerProperties")
1155            .field("layer_name", &unsafe {
1156                ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr())
1157            })
1158            .field("spec_version", &self.spec_version)
1159            .field("implementation_version", &self.implementation_version)
1160            .field("description", &unsafe {
1161                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
1162            })
1163            .finish()
1164    }
1165}
1166impl ::std::default::Default for LayerProperties {
1167    fn default() -> Self {
1168        Self {
1169            layer_name: unsafe { ::std::mem::zeroed() },
1170            spec_version: u32::default(),
1171            implementation_version: u32::default(),
1172            description: unsafe { ::std::mem::zeroed() },
1173        }
1174    }
1175}
1176impl LayerProperties {
1177    pub fn builder<'a>() -> LayerPropertiesBuilder<'a> {
1178        LayerPropertiesBuilder {
1179            inner: Self::default(),
1180            marker: ::std::marker::PhantomData,
1181        }
1182    }
1183}
1184#[repr(transparent)]
1185pub struct LayerPropertiesBuilder<'a> {
1186    inner: LayerProperties,
1187    marker: ::std::marker::PhantomData<&'a ()>,
1188}
1189impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> {
1190    type Target = LayerProperties;
1191    fn deref(&self) -> &Self::Target {
1192        &self.inner
1193    }
1194}
1195impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> {
1196    fn deref_mut(&mut self) -> &mut Self::Target {
1197        &mut self.inner
1198    }
1199}
1200impl<'a> LayerPropertiesBuilder<'a> {
1201    pub fn layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
1202        self.inner.layer_name = layer_name;
1203        self
1204    }
1205    pub fn spec_version(mut self, spec_version: u32) -> Self {
1206        self.inner.spec_version = spec_version;
1207        self
1208    }
1209    pub fn implementation_version(mut self, implementation_version: u32) -> Self {
1210        self.inner.implementation_version = implementation_version;
1211        self
1212    }
1213    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
1214        self.inner.description = description;
1215        self
1216    }
1217    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1218    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1219    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1220    pub fn build(self) -> LayerProperties {
1221        self.inner
1222    }
1223}
1224#[repr(C)]
1225#[cfg_attr(feature = "debug", derive(Debug))]
1226#[derive(Copy, Clone)]
1227#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkApplicationInfo.html>"]
1228pub struct ApplicationInfo {
1229    pub s_type: StructureType,
1230    pub p_next: *const c_void,
1231    pub p_application_name: *const c_char,
1232    pub application_version: u32,
1233    pub p_engine_name: *const c_char,
1234    pub engine_version: u32,
1235    pub api_version: u32,
1236}
1237impl ::std::default::Default for ApplicationInfo {
1238    fn default() -> Self {
1239        Self {
1240            s_type: StructureType::APPLICATION_INFO,
1241            p_next: ::std::ptr::null(),
1242            p_application_name: ::std::ptr::null(),
1243            application_version: u32::default(),
1244            p_engine_name: ::std::ptr::null(),
1245            engine_version: u32::default(),
1246            api_version: u32::default(),
1247        }
1248    }
1249}
1250impl ApplicationInfo {
1251    pub fn builder<'a>() -> ApplicationInfoBuilder<'a> {
1252        ApplicationInfoBuilder {
1253            inner: Self::default(),
1254            marker: ::std::marker::PhantomData,
1255        }
1256    }
1257}
1258#[repr(transparent)]
1259pub struct ApplicationInfoBuilder<'a> {
1260    inner: ApplicationInfo,
1261    marker: ::std::marker::PhantomData<&'a ()>,
1262}
1263impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> {
1264    type Target = ApplicationInfo;
1265    fn deref(&self) -> &Self::Target {
1266        &self.inner
1267    }
1268}
1269impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> {
1270    fn deref_mut(&mut self) -> &mut Self::Target {
1271        &mut self.inner
1272    }
1273}
1274impl<'a> ApplicationInfoBuilder<'a> {
1275    pub fn application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self {
1276        self.inner.p_application_name = application_name.as_ptr();
1277        self
1278    }
1279    pub fn application_version(mut self, application_version: u32) -> Self {
1280        self.inner.application_version = application_version;
1281        self
1282    }
1283    pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self {
1284        self.inner.p_engine_name = engine_name.as_ptr();
1285        self
1286    }
1287    pub fn engine_version(mut self, engine_version: u32) -> Self {
1288        self.inner.engine_version = engine_version;
1289        self
1290    }
1291    pub fn api_version(mut self, api_version: u32) -> Self {
1292        self.inner.api_version = api_version;
1293        self
1294    }
1295    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1296    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1297    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1298    pub fn build(self) -> ApplicationInfo {
1299        self.inner
1300    }
1301}
1302#[repr(C)]
1303#[derive(Copy, Clone)]
1304#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAllocationCallbacks.html>"]
1305pub struct AllocationCallbacks {
1306    pub p_user_data: *mut c_void,
1307    pub pfn_allocation: PFN_vkAllocationFunction,
1308    pub pfn_reallocation: PFN_vkReallocationFunction,
1309    pub pfn_free: PFN_vkFreeFunction,
1310    pub pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1311    pub pfn_internal_free: PFN_vkInternalFreeNotification,
1312}
1313#[cfg(feature = "debug")]
1314impl fmt::Debug for AllocationCallbacks {
1315    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1316        fmt.debug_struct("AllocationCallbacks")
1317            .field("p_user_data", &self.p_user_data)
1318            .field(
1319                "pfn_allocation",
1320                &(self.pfn_allocation.map(|x| x as *const ())),
1321            )
1322            .field(
1323                "pfn_reallocation",
1324                &(self.pfn_reallocation.map(|x| x as *const ())),
1325            )
1326            .field("pfn_free", &(self.pfn_free.map(|x| x as *const ())))
1327            .field(
1328                "pfn_internal_allocation",
1329                &(self.pfn_internal_allocation.map(|x| x as *const ())),
1330            )
1331            .field(
1332                "pfn_internal_free",
1333                &(self.pfn_internal_free.map(|x| x as *const ())),
1334            )
1335            .finish()
1336    }
1337}
1338impl ::std::default::Default for AllocationCallbacks {
1339    fn default() -> Self {
1340        Self {
1341            p_user_data: ::std::ptr::null_mut(),
1342            pfn_allocation: PFN_vkAllocationFunction::default(),
1343            pfn_reallocation: PFN_vkReallocationFunction::default(),
1344            pfn_free: PFN_vkFreeFunction::default(),
1345            pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(),
1346            pfn_internal_free: PFN_vkInternalFreeNotification::default(),
1347        }
1348    }
1349}
1350impl AllocationCallbacks {
1351    pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> {
1352        AllocationCallbacksBuilder {
1353            inner: Self::default(),
1354            marker: ::std::marker::PhantomData,
1355        }
1356    }
1357}
1358#[repr(transparent)]
1359pub struct AllocationCallbacksBuilder<'a> {
1360    inner: AllocationCallbacks,
1361    marker: ::std::marker::PhantomData<&'a ()>,
1362}
1363impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> {
1364    type Target = AllocationCallbacks;
1365    fn deref(&self) -> &Self::Target {
1366        &self.inner
1367    }
1368}
1369impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> {
1370    fn deref_mut(&mut self) -> &mut Self::Target {
1371        &mut self.inner
1372    }
1373}
1374impl<'a> AllocationCallbacksBuilder<'a> {
1375    pub fn user_data(mut self, user_data: *mut c_void) -> Self {
1376        self.inner.p_user_data = user_data;
1377        self
1378    }
1379    pub fn pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self {
1380        self.inner.pfn_allocation = pfn_allocation;
1381        self
1382    }
1383    pub fn pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self {
1384        self.inner.pfn_reallocation = pfn_reallocation;
1385        self
1386    }
1387    pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self {
1388        self.inner.pfn_free = pfn_free;
1389        self
1390    }
1391    pub fn pfn_internal_allocation(
1392        mut self,
1393        pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1394    ) -> Self {
1395        self.inner.pfn_internal_allocation = pfn_internal_allocation;
1396        self
1397    }
1398    pub fn pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self {
1399        self.inner.pfn_internal_free = pfn_internal_free;
1400        self
1401    }
1402    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1403    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1404    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1405    pub fn build(self) -> AllocationCallbacks {
1406        self.inner
1407    }
1408}
1409#[repr(C)]
1410#[cfg_attr(feature = "debug", derive(Debug))]
1411#[derive(Copy, Clone)]
1412#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateInfo.html>"]
1413pub struct DeviceQueueCreateInfo {
1414    pub s_type: StructureType,
1415    pub p_next: *const c_void,
1416    pub flags: DeviceQueueCreateFlags,
1417    pub queue_family_index: u32,
1418    pub queue_count: u32,
1419    pub p_queue_priorities: *const f32,
1420}
1421impl ::std::default::Default for DeviceQueueCreateInfo {
1422    fn default() -> Self {
1423        Self {
1424            s_type: StructureType::DEVICE_QUEUE_CREATE_INFO,
1425            p_next: ::std::ptr::null(),
1426            flags: DeviceQueueCreateFlags::default(),
1427            queue_family_index: u32::default(),
1428            queue_count: u32::default(),
1429            p_queue_priorities: ::std::ptr::null(),
1430        }
1431    }
1432}
1433impl DeviceQueueCreateInfo {
1434    pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> {
1435        DeviceQueueCreateInfoBuilder {
1436            inner: Self::default(),
1437            marker: ::std::marker::PhantomData,
1438        }
1439    }
1440}
1441#[repr(transparent)]
1442pub struct DeviceQueueCreateInfoBuilder<'a> {
1443    inner: DeviceQueueCreateInfo,
1444    marker: ::std::marker::PhantomData<&'a ()>,
1445}
1446pub unsafe trait ExtendsDeviceQueueCreateInfo {}
1447impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> {
1448    type Target = DeviceQueueCreateInfo;
1449    fn deref(&self) -> &Self::Target {
1450        &self.inner
1451    }
1452}
1453impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
1454    fn deref_mut(&mut self) -> &mut Self::Target {
1455        &mut self.inner
1456    }
1457}
1458impl<'a> DeviceQueueCreateInfoBuilder<'a> {
1459    pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
1460        self.inner.flags = flags;
1461        self
1462    }
1463    pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
1464        self.inner.queue_family_index = queue_family_index;
1465        self
1466    }
1467    pub fn queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self {
1468        self.inner.queue_count = queue_priorities.len() as _;
1469        self.inner.p_queue_priorities = queue_priorities.as_ptr();
1470        self
1471    }
1472    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1473    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1474    #[doc = r" valid extension structs can be pushed into the chain."]
1475    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1476    #[doc = r" chain will look like `A -> D -> B -> C`."]
1477    pub fn push_next<T: ExtendsDeviceQueueCreateInfo>(mut self, next: &'a mut T) -> Self {
1478        unsafe {
1479            let next_ptr = <*const T>::cast(next);
1480            let last_next = ptr_chain_iter(next).last().unwrap();
1481            (*last_next).p_next = self.inner.p_next as _;
1482            self.inner.p_next = next_ptr;
1483        }
1484        self
1485    }
1486    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1487    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1488    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1489    pub fn build(self) -> DeviceQueueCreateInfo {
1490        self.inner
1491    }
1492}
1493#[repr(C)]
1494#[cfg_attr(feature = "debug", derive(Debug))]
1495#[derive(Copy, Clone)]
1496#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateInfo.html>"]
1497pub struct DeviceCreateInfo {
1498    pub s_type: StructureType,
1499    pub p_next: *const c_void,
1500    pub flags: DeviceCreateFlags,
1501    pub queue_create_info_count: u32,
1502    pub p_queue_create_infos: *const DeviceQueueCreateInfo,
1503    pub enabled_layer_count: u32,
1504    pub pp_enabled_layer_names: *const *const c_char,
1505    pub enabled_extension_count: u32,
1506    pub pp_enabled_extension_names: *const *const c_char,
1507    pub p_enabled_features: *const PhysicalDeviceFeatures,
1508}
1509impl ::std::default::Default for DeviceCreateInfo {
1510    fn default() -> Self {
1511        Self {
1512            s_type: StructureType::DEVICE_CREATE_INFO,
1513            p_next: ::std::ptr::null(),
1514            flags: DeviceCreateFlags::default(),
1515            queue_create_info_count: u32::default(),
1516            p_queue_create_infos: ::std::ptr::null(),
1517            enabled_layer_count: u32::default(),
1518            pp_enabled_layer_names: ::std::ptr::null(),
1519            enabled_extension_count: u32::default(),
1520            pp_enabled_extension_names: ::std::ptr::null(),
1521            p_enabled_features: ::std::ptr::null(),
1522        }
1523    }
1524}
1525impl DeviceCreateInfo {
1526    pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> {
1527        DeviceCreateInfoBuilder {
1528            inner: Self::default(),
1529            marker: ::std::marker::PhantomData,
1530        }
1531    }
1532}
1533#[repr(transparent)]
1534pub struct DeviceCreateInfoBuilder<'a> {
1535    inner: DeviceCreateInfo,
1536    marker: ::std::marker::PhantomData<&'a ()>,
1537}
1538pub unsafe trait ExtendsDeviceCreateInfo {}
1539impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> {
1540    type Target = DeviceCreateInfo;
1541    fn deref(&self) -> &Self::Target {
1542        &self.inner
1543    }
1544}
1545impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
1546    fn deref_mut(&mut self) -> &mut Self::Target {
1547        &mut self.inner
1548    }
1549}
1550impl<'a> DeviceCreateInfoBuilder<'a> {
1551    pub fn flags(mut self, flags: DeviceCreateFlags) -> Self {
1552        self.inner.flags = flags;
1553        self
1554    }
1555    pub fn queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self {
1556        self.inner.queue_create_info_count = queue_create_infos.len() as _;
1557        self.inner.p_queue_create_infos = queue_create_infos.as_ptr();
1558        self
1559    }
1560    pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
1561        self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1562        self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1563        self
1564    }
1565    pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
1566        self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1567        self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1568        self
1569    }
1570    pub fn enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self {
1571        self.inner.p_enabled_features = enabled_features;
1572        self
1573    }
1574    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1575    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1576    #[doc = r" valid extension structs can be pushed into the chain."]
1577    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1578    #[doc = r" chain will look like `A -> D -> B -> C`."]
1579    pub fn push_next<T: ExtendsDeviceCreateInfo>(mut self, next: &'a mut T) -> Self {
1580        unsafe {
1581            let next_ptr = <*const T>::cast(next);
1582            let last_next = ptr_chain_iter(next).last().unwrap();
1583            (*last_next).p_next = self.inner.p_next as _;
1584            self.inner.p_next = next_ptr;
1585        }
1586        self
1587    }
1588    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1589    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1590    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1591    pub fn build(self) -> DeviceCreateInfo {
1592        self.inner
1593    }
1594}
1595#[repr(C)]
1596#[cfg_attr(feature = "debug", derive(Debug))]
1597#[derive(Copy, Clone)]
1598#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateInfo.html>"]
1599pub struct InstanceCreateInfo {
1600    pub s_type: StructureType,
1601    pub p_next: *const c_void,
1602    pub flags: InstanceCreateFlags,
1603    pub p_application_info: *const ApplicationInfo,
1604    pub enabled_layer_count: u32,
1605    pub pp_enabled_layer_names: *const *const c_char,
1606    pub enabled_extension_count: u32,
1607    pub pp_enabled_extension_names: *const *const c_char,
1608}
1609impl ::std::default::Default for InstanceCreateInfo {
1610    fn default() -> Self {
1611        Self {
1612            s_type: StructureType::INSTANCE_CREATE_INFO,
1613            p_next: ::std::ptr::null(),
1614            flags: InstanceCreateFlags::default(),
1615            p_application_info: ::std::ptr::null(),
1616            enabled_layer_count: u32::default(),
1617            pp_enabled_layer_names: ::std::ptr::null(),
1618            enabled_extension_count: u32::default(),
1619            pp_enabled_extension_names: ::std::ptr::null(),
1620        }
1621    }
1622}
1623impl InstanceCreateInfo {
1624    pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> {
1625        InstanceCreateInfoBuilder {
1626            inner: Self::default(),
1627            marker: ::std::marker::PhantomData,
1628        }
1629    }
1630}
1631#[repr(transparent)]
1632pub struct InstanceCreateInfoBuilder<'a> {
1633    inner: InstanceCreateInfo,
1634    marker: ::std::marker::PhantomData<&'a ()>,
1635}
1636pub unsafe trait ExtendsInstanceCreateInfo {}
1637impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> {
1638    type Target = InstanceCreateInfo;
1639    fn deref(&self) -> &Self::Target {
1640        &self.inner
1641    }
1642}
1643impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
1644    fn deref_mut(&mut self) -> &mut Self::Target {
1645        &mut self.inner
1646    }
1647}
1648impl<'a> InstanceCreateInfoBuilder<'a> {
1649    pub fn flags(mut self, flags: InstanceCreateFlags) -> Self {
1650        self.inner.flags = flags;
1651        self
1652    }
1653    pub fn application_info(mut self, application_info: &'a ApplicationInfo) -> Self {
1654        self.inner.p_application_info = application_info;
1655        self
1656    }
1657    pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
1658        self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1659        self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1660        self
1661    }
1662    pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
1663        self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1664        self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1665        self
1666    }
1667    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1668    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1669    #[doc = r" valid extension structs can be pushed into the chain."]
1670    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1671    #[doc = r" chain will look like `A -> D -> B -> C`."]
1672    pub fn push_next<T: ExtendsInstanceCreateInfo>(mut self, next: &'a mut T) -> Self {
1673        unsafe {
1674            let next_ptr = <*const T>::cast(next);
1675            let last_next = ptr_chain_iter(next).last().unwrap();
1676            (*last_next).p_next = self.inner.p_next as _;
1677            self.inner.p_next = next_ptr;
1678        }
1679        self
1680    }
1681    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1682    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1683    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1684    pub fn build(self) -> InstanceCreateInfo {
1685        self.inner
1686    }
1687}
1688#[repr(C)]
1689#[cfg_attr(feature = "debug", derive(Debug))]
1690#[derive(Copy, Clone, Default)]
1691#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties.html>"]
1692pub struct QueueFamilyProperties {
1693    pub queue_flags: QueueFlags,
1694    pub queue_count: u32,
1695    pub timestamp_valid_bits: u32,
1696    pub min_image_transfer_granularity: Extent3D,
1697}
1698impl QueueFamilyProperties {
1699    pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> {
1700        QueueFamilyPropertiesBuilder {
1701            inner: Self::default(),
1702            marker: ::std::marker::PhantomData,
1703        }
1704    }
1705}
1706#[repr(transparent)]
1707pub struct QueueFamilyPropertiesBuilder<'a> {
1708    inner: QueueFamilyProperties,
1709    marker: ::std::marker::PhantomData<&'a ()>,
1710}
1711impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> {
1712    type Target = QueueFamilyProperties;
1713    fn deref(&self) -> &Self::Target {
1714        &self.inner
1715    }
1716}
1717impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> {
1718    fn deref_mut(&mut self) -> &mut Self::Target {
1719        &mut self.inner
1720    }
1721}
1722impl<'a> QueueFamilyPropertiesBuilder<'a> {
1723    pub fn queue_flags(mut self, queue_flags: QueueFlags) -> Self {
1724        self.inner.queue_flags = queue_flags;
1725        self
1726    }
1727    pub fn queue_count(mut self, queue_count: u32) -> Self {
1728        self.inner.queue_count = queue_count;
1729        self
1730    }
1731    pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self {
1732        self.inner.timestamp_valid_bits = timestamp_valid_bits;
1733        self
1734    }
1735    pub fn min_image_transfer_granularity(
1736        mut self,
1737        min_image_transfer_granularity: Extent3D,
1738    ) -> Self {
1739        self.inner.min_image_transfer_granularity = min_image_transfer_granularity;
1740        self
1741    }
1742    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1743    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1744    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1745    pub fn build(self) -> QueueFamilyProperties {
1746        self.inner
1747    }
1748}
1749#[repr(C)]
1750#[cfg_attr(feature = "debug", derive(Debug))]
1751#[derive(Copy, Clone)]
1752#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties.html>"]
1753pub struct PhysicalDeviceMemoryProperties {
1754    pub memory_type_count: u32,
1755    pub memory_types: [MemoryType; MAX_MEMORY_TYPES],
1756    pub memory_heap_count: u32,
1757    pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
1758}
1759impl ::std::default::Default for PhysicalDeviceMemoryProperties {
1760    fn default() -> Self {
1761        Self {
1762            memory_type_count: u32::default(),
1763            memory_types: unsafe { ::std::mem::zeroed() },
1764            memory_heap_count: u32::default(),
1765            memory_heaps: unsafe { ::std::mem::zeroed() },
1766        }
1767    }
1768}
1769impl PhysicalDeviceMemoryProperties {
1770    pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1771        PhysicalDeviceMemoryPropertiesBuilder {
1772            inner: Self::default(),
1773            marker: ::std::marker::PhantomData,
1774        }
1775    }
1776}
1777#[repr(transparent)]
1778pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> {
1779    inner: PhysicalDeviceMemoryProperties,
1780    marker: ::std::marker::PhantomData<&'a ()>,
1781}
1782impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> {
1783    type Target = PhysicalDeviceMemoryProperties;
1784    fn deref(&self) -> &Self::Target {
1785        &self.inner
1786    }
1787}
1788impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> {
1789    fn deref_mut(&mut self) -> &mut Self::Target {
1790        &mut self.inner
1791    }
1792}
1793impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1794    pub fn memory_type_count(mut self, memory_type_count: u32) -> Self {
1795        self.inner.memory_type_count = memory_type_count;
1796        self
1797    }
1798    pub fn memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self {
1799        self.inner.memory_types = memory_types;
1800        self
1801    }
1802    pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self {
1803        self.inner.memory_heap_count = memory_heap_count;
1804        self
1805    }
1806    pub fn memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self {
1807        self.inner.memory_heaps = memory_heaps;
1808        self
1809    }
1810    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1811    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1812    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1813    pub fn build(self) -> PhysicalDeviceMemoryProperties {
1814        self.inner
1815    }
1816}
1817#[repr(C)]
1818#[cfg_attr(feature = "debug", derive(Debug))]
1819#[derive(Copy, Clone)]
1820#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateInfo.html>"]
1821pub struct MemoryAllocateInfo {
1822    pub s_type: StructureType,
1823    pub p_next: *const c_void,
1824    pub allocation_size: DeviceSize,
1825    pub memory_type_index: u32,
1826}
1827impl ::std::default::Default for MemoryAllocateInfo {
1828    fn default() -> Self {
1829        Self {
1830            s_type: StructureType::MEMORY_ALLOCATE_INFO,
1831            p_next: ::std::ptr::null(),
1832            allocation_size: DeviceSize::default(),
1833            memory_type_index: u32::default(),
1834        }
1835    }
1836}
1837impl MemoryAllocateInfo {
1838    pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> {
1839        MemoryAllocateInfoBuilder {
1840            inner: Self::default(),
1841            marker: ::std::marker::PhantomData,
1842        }
1843    }
1844}
1845#[repr(transparent)]
1846pub struct MemoryAllocateInfoBuilder<'a> {
1847    inner: MemoryAllocateInfo,
1848    marker: ::std::marker::PhantomData<&'a ()>,
1849}
1850pub unsafe trait ExtendsMemoryAllocateInfo {}
1851impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> {
1852    type Target = MemoryAllocateInfo;
1853    fn deref(&self) -> &Self::Target {
1854        &self.inner
1855    }
1856}
1857impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
1858    fn deref_mut(&mut self) -> &mut Self::Target {
1859        &mut self.inner
1860    }
1861}
1862impl<'a> MemoryAllocateInfoBuilder<'a> {
1863    pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
1864        self.inner.allocation_size = allocation_size;
1865        self
1866    }
1867    pub fn memory_type_index(mut self, memory_type_index: u32) -> Self {
1868        self.inner.memory_type_index = memory_type_index;
1869        self
1870    }
1871    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1872    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1873    #[doc = r" valid extension structs can be pushed into the chain."]
1874    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1875    #[doc = r" chain will look like `A -> D -> B -> C`."]
1876    pub fn push_next<T: ExtendsMemoryAllocateInfo>(mut self, next: &'a mut T) -> Self {
1877        unsafe {
1878            let next_ptr = <*const T>::cast(next);
1879            let last_next = ptr_chain_iter(next).last().unwrap();
1880            (*last_next).p_next = self.inner.p_next as _;
1881            self.inner.p_next = next_ptr;
1882        }
1883        self
1884    }
1885    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1886    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1887    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1888    pub fn build(self) -> MemoryAllocateInfo {
1889        self.inner
1890    }
1891}
1892#[repr(C)]
1893#[cfg_attr(feature = "debug", derive(Debug))]
1894#[derive(Copy, Clone, Default)]
1895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements.html>"]
1896pub struct MemoryRequirements {
1897    pub size: DeviceSize,
1898    pub alignment: DeviceSize,
1899    pub memory_type_bits: u32,
1900}
1901impl MemoryRequirements {
1902    pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> {
1903        MemoryRequirementsBuilder {
1904            inner: Self::default(),
1905            marker: ::std::marker::PhantomData,
1906        }
1907    }
1908}
1909#[repr(transparent)]
1910pub struct MemoryRequirementsBuilder<'a> {
1911    inner: MemoryRequirements,
1912    marker: ::std::marker::PhantomData<&'a ()>,
1913}
1914impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> {
1915    type Target = MemoryRequirements;
1916    fn deref(&self) -> &Self::Target {
1917        &self.inner
1918    }
1919}
1920impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> {
1921    fn deref_mut(&mut self) -> &mut Self::Target {
1922        &mut self.inner
1923    }
1924}
1925impl<'a> MemoryRequirementsBuilder<'a> {
1926    pub fn size(mut self, size: DeviceSize) -> Self {
1927        self.inner.size = size;
1928        self
1929    }
1930    pub fn alignment(mut self, alignment: DeviceSize) -> Self {
1931        self.inner.alignment = alignment;
1932        self
1933    }
1934    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
1935        self.inner.memory_type_bits = memory_type_bits;
1936        self
1937    }
1938    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1939    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1940    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1941    pub fn build(self) -> MemoryRequirements {
1942        self.inner
1943    }
1944}
1945#[repr(C)]
1946#[cfg_attr(feature = "debug", derive(Debug))]
1947#[derive(Copy, Clone, Default)]
1948#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties.html>"]
1949pub struct SparseImageFormatProperties {
1950    pub aspect_mask: ImageAspectFlags,
1951    pub image_granularity: Extent3D,
1952    pub flags: SparseImageFormatFlags,
1953}
1954impl SparseImageFormatProperties {
1955    pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> {
1956        SparseImageFormatPropertiesBuilder {
1957            inner: Self::default(),
1958            marker: ::std::marker::PhantomData,
1959        }
1960    }
1961}
1962#[repr(transparent)]
1963pub struct SparseImageFormatPropertiesBuilder<'a> {
1964    inner: SparseImageFormatProperties,
1965    marker: ::std::marker::PhantomData<&'a ()>,
1966}
1967impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> {
1968    type Target = SparseImageFormatProperties;
1969    fn deref(&self) -> &Self::Target {
1970        &self.inner
1971    }
1972}
1973impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> {
1974    fn deref_mut(&mut self) -> &mut Self::Target {
1975        &mut self.inner
1976    }
1977}
1978impl<'a> SparseImageFormatPropertiesBuilder<'a> {
1979    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
1980        self.inner.aspect_mask = aspect_mask;
1981        self
1982    }
1983    pub fn image_granularity(mut self, image_granularity: Extent3D) -> Self {
1984        self.inner.image_granularity = image_granularity;
1985        self
1986    }
1987    pub fn flags(mut self, flags: SparseImageFormatFlags) -> Self {
1988        self.inner.flags = flags;
1989        self
1990    }
1991    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1992    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1993    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
1994    pub fn build(self) -> SparseImageFormatProperties {
1995        self.inner
1996    }
1997}
1998#[repr(C)]
1999#[cfg_attr(feature = "debug", derive(Debug))]
2000#[derive(Copy, Clone, Default)]
2001#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements.html>"]
2002pub struct SparseImageMemoryRequirements {
2003    pub format_properties: SparseImageFormatProperties,
2004    pub image_mip_tail_first_lod: u32,
2005    pub image_mip_tail_size: DeviceSize,
2006    pub image_mip_tail_offset: DeviceSize,
2007    pub image_mip_tail_stride: DeviceSize,
2008}
2009impl SparseImageMemoryRequirements {
2010    pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> {
2011        SparseImageMemoryRequirementsBuilder {
2012            inner: Self::default(),
2013            marker: ::std::marker::PhantomData,
2014        }
2015    }
2016}
2017#[repr(transparent)]
2018pub struct SparseImageMemoryRequirementsBuilder<'a> {
2019    inner: SparseImageMemoryRequirements,
2020    marker: ::std::marker::PhantomData<&'a ()>,
2021}
2022impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> {
2023    type Target = SparseImageMemoryRequirements;
2024    fn deref(&self) -> &Self::Target {
2025        &self.inner
2026    }
2027}
2028impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> {
2029    fn deref_mut(&mut self) -> &mut Self::Target {
2030        &mut self.inner
2031    }
2032}
2033impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
2034    pub fn format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self {
2035        self.inner.format_properties = format_properties;
2036        self
2037    }
2038    pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self {
2039        self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod;
2040        self
2041    }
2042    pub fn image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self {
2043        self.inner.image_mip_tail_size = image_mip_tail_size;
2044        self
2045    }
2046    pub fn image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self {
2047        self.inner.image_mip_tail_offset = image_mip_tail_offset;
2048        self
2049    }
2050    pub fn image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self {
2051        self.inner.image_mip_tail_stride = image_mip_tail_stride;
2052        self
2053    }
2054    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2055    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2056    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2057    pub fn build(self) -> SparseImageMemoryRequirements {
2058        self.inner
2059    }
2060}
2061#[repr(C)]
2062#[cfg_attr(feature = "debug", derive(Debug))]
2063#[derive(Copy, Clone, Default)]
2064#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryType.html>"]
2065pub struct MemoryType {
2066    pub property_flags: MemoryPropertyFlags,
2067    pub heap_index: u32,
2068}
2069impl MemoryType {
2070    pub fn builder<'a>() -> MemoryTypeBuilder<'a> {
2071        MemoryTypeBuilder {
2072            inner: Self::default(),
2073            marker: ::std::marker::PhantomData,
2074        }
2075    }
2076}
2077#[repr(transparent)]
2078pub struct MemoryTypeBuilder<'a> {
2079    inner: MemoryType,
2080    marker: ::std::marker::PhantomData<&'a ()>,
2081}
2082impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> {
2083    type Target = MemoryType;
2084    fn deref(&self) -> &Self::Target {
2085        &self.inner
2086    }
2087}
2088impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> {
2089    fn deref_mut(&mut self) -> &mut Self::Target {
2090        &mut self.inner
2091    }
2092}
2093impl<'a> MemoryTypeBuilder<'a> {
2094    pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self {
2095        self.inner.property_flags = property_flags;
2096        self
2097    }
2098    pub fn heap_index(mut self, heap_index: u32) -> Self {
2099        self.inner.heap_index = heap_index;
2100        self
2101    }
2102    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2103    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2104    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2105    pub fn build(self) -> MemoryType {
2106        self.inner
2107    }
2108}
2109#[repr(C)]
2110#[cfg_attr(feature = "debug", derive(Debug))]
2111#[derive(Copy, Clone, Default)]
2112#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeap.html>"]
2113pub struct MemoryHeap {
2114    pub size: DeviceSize,
2115    pub flags: MemoryHeapFlags,
2116}
2117impl MemoryHeap {
2118    pub fn builder<'a>() -> MemoryHeapBuilder<'a> {
2119        MemoryHeapBuilder {
2120            inner: Self::default(),
2121            marker: ::std::marker::PhantomData,
2122        }
2123    }
2124}
2125#[repr(transparent)]
2126pub struct MemoryHeapBuilder<'a> {
2127    inner: MemoryHeap,
2128    marker: ::std::marker::PhantomData<&'a ()>,
2129}
2130impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> {
2131    type Target = MemoryHeap;
2132    fn deref(&self) -> &Self::Target {
2133        &self.inner
2134    }
2135}
2136impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> {
2137    fn deref_mut(&mut self) -> &mut Self::Target {
2138        &mut self.inner
2139    }
2140}
2141impl<'a> MemoryHeapBuilder<'a> {
2142    pub fn size(mut self, size: DeviceSize) -> Self {
2143        self.inner.size = size;
2144        self
2145    }
2146    pub fn flags(mut self, flags: MemoryHeapFlags) -> Self {
2147        self.inner.flags = flags;
2148        self
2149    }
2150    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2151    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2152    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2153    pub fn build(self) -> MemoryHeap {
2154        self.inner
2155    }
2156}
2157#[repr(C)]
2158#[cfg_attr(feature = "debug", derive(Debug))]
2159#[derive(Copy, Clone)]
2160#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMappedMemoryRange.html>"]
2161pub struct MappedMemoryRange {
2162    pub s_type: StructureType,
2163    pub p_next: *const c_void,
2164    pub memory: DeviceMemory,
2165    pub offset: DeviceSize,
2166    pub size: DeviceSize,
2167}
2168impl ::std::default::Default for MappedMemoryRange {
2169    fn default() -> Self {
2170        Self {
2171            s_type: StructureType::MAPPED_MEMORY_RANGE,
2172            p_next: ::std::ptr::null(),
2173            memory: DeviceMemory::default(),
2174            offset: DeviceSize::default(),
2175            size: DeviceSize::default(),
2176        }
2177    }
2178}
2179impl MappedMemoryRange {
2180    pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> {
2181        MappedMemoryRangeBuilder {
2182            inner: Self::default(),
2183            marker: ::std::marker::PhantomData,
2184        }
2185    }
2186}
2187#[repr(transparent)]
2188pub struct MappedMemoryRangeBuilder<'a> {
2189    inner: MappedMemoryRange,
2190    marker: ::std::marker::PhantomData<&'a ()>,
2191}
2192impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> {
2193    type Target = MappedMemoryRange;
2194    fn deref(&self) -> &Self::Target {
2195        &self.inner
2196    }
2197}
2198impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
2199    fn deref_mut(&mut self) -> &mut Self::Target {
2200        &mut self.inner
2201    }
2202}
2203impl<'a> MappedMemoryRangeBuilder<'a> {
2204    pub fn memory(mut self, memory: DeviceMemory) -> Self {
2205        self.inner.memory = memory;
2206        self
2207    }
2208    pub fn offset(mut self, offset: DeviceSize) -> Self {
2209        self.inner.offset = offset;
2210        self
2211    }
2212    pub fn size(mut self, size: DeviceSize) -> Self {
2213        self.inner.size = size;
2214        self
2215    }
2216    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2217    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2218    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2219    pub fn build(self) -> MappedMemoryRange {
2220        self.inner
2221    }
2222}
2223#[repr(C)]
2224#[cfg_attr(feature = "debug", derive(Debug))]
2225#[derive(Copy, Clone, Default)]
2226#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties.html>"]
2227pub struct FormatProperties {
2228    pub linear_tiling_features: FormatFeatureFlags,
2229    pub optimal_tiling_features: FormatFeatureFlags,
2230    pub buffer_features: FormatFeatureFlags,
2231}
2232impl FormatProperties {
2233    pub fn builder<'a>() -> FormatPropertiesBuilder<'a> {
2234        FormatPropertiesBuilder {
2235            inner: Self::default(),
2236            marker: ::std::marker::PhantomData,
2237        }
2238    }
2239}
2240#[repr(transparent)]
2241pub struct FormatPropertiesBuilder<'a> {
2242    inner: FormatProperties,
2243    marker: ::std::marker::PhantomData<&'a ()>,
2244}
2245impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> {
2246    type Target = FormatProperties;
2247    fn deref(&self) -> &Self::Target {
2248        &self.inner
2249    }
2250}
2251impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> {
2252    fn deref_mut(&mut self) -> &mut Self::Target {
2253        &mut self.inner
2254    }
2255}
2256impl<'a> FormatPropertiesBuilder<'a> {
2257    pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self {
2258        self.inner.linear_tiling_features = linear_tiling_features;
2259        self
2260    }
2261    pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self {
2262        self.inner.optimal_tiling_features = optimal_tiling_features;
2263        self
2264    }
2265    pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self {
2266        self.inner.buffer_features = buffer_features;
2267        self
2268    }
2269    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2270    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2271    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2272    pub fn build(self) -> FormatProperties {
2273        self.inner
2274    }
2275}
2276#[repr(C)]
2277#[cfg_attr(feature = "debug", derive(Debug))]
2278#[derive(Copy, Clone, Default)]
2279#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties.html>"]
2280pub struct ImageFormatProperties {
2281    pub max_extent: Extent3D,
2282    pub max_mip_levels: u32,
2283    pub max_array_layers: u32,
2284    pub sample_counts: SampleCountFlags,
2285    pub max_resource_size: DeviceSize,
2286}
2287impl ImageFormatProperties {
2288    pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> {
2289        ImageFormatPropertiesBuilder {
2290            inner: Self::default(),
2291            marker: ::std::marker::PhantomData,
2292        }
2293    }
2294}
2295#[repr(transparent)]
2296pub struct ImageFormatPropertiesBuilder<'a> {
2297    inner: ImageFormatProperties,
2298    marker: ::std::marker::PhantomData<&'a ()>,
2299}
2300impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> {
2301    type Target = ImageFormatProperties;
2302    fn deref(&self) -> &Self::Target {
2303        &self.inner
2304    }
2305}
2306impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> {
2307    fn deref_mut(&mut self) -> &mut Self::Target {
2308        &mut self.inner
2309    }
2310}
2311impl<'a> ImageFormatPropertiesBuilder<'a> {
2312    pub fn max_extent(mut self, max_extent: Extent3D) -> Self {
2313        self.inner.max_extent = max_extent;
2314        self
2315    }
2316    pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self {
2317        self.inner.max_mip_levels = max_mip_levels;
2318        self
2319    }
2320    pub fn max_array_layers(mut self, max_array_layers: u32) -> Self {
2321        self.inner.max_array_layers = max_array_layers;
2322        self
2323    }
2324    pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
2325        self.inner.sample_counts = sample_counts;
2326        self
2327    }
2328    pub fn max_resource_size(mut self, max_resource_size: DeviceSize) -> Self {
2329        self.inner.max_resource_size = max_resource_size;
2330        self
2331    }
2332    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2333    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2334    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2335    pub fn build(self) -> ImageFormatProperties {
2336        self.inner
2337    }
2338}
2339#[repr(C)]
2340#[cfg_attr(feature = "debug", derive(Debug))]
2341#[derive(Copy, Clone, Default)]
2342#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferInfo.html>"]
2343pub struct DescriptorBufferInfo {
2344    pub buffer: Buffer,
2345    pub offset: DeviceSize,
2346    pub range: DeviceSize,
2347}
2348impl DescriptorBufferInfo {
2349    pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> {
2350        DescriptorBufferInfoBuilder {
2351            inner: Self::default(),
2352            marker: ::std::marker::PhantomData,
2353        }
2354    }
2355}
2356#[repr(transparent)]
2357pub struct DescriptorBufferInfoBuilder<'a> {
2358    inner: DescriptorBufferInfo,
2359    marker: ::std::marker::PhantomData<&'a ()>,
2360}
2361impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> {
2362    type Target = DescriptorBufferInfo;
2363    fn deref(&self) -> &Self::Target {
2364        &self.inner
2365    }
2366}
2367impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> {
2368    fn deref_mut(&mut self) -> &mut Self::Target {
2369        &mut self.inner
2370    }
2371}
2372impl<'a> DescriptorBufferInfoBuilder<'a> {
2373    pub fn buffer(mut self, buffer: Buffer) -> Self {
2374        self.inner.buffer = buffer;
2375        self
2376    }
2377    pub fn offset(mut self, offset: DeviceSize) -> Self {
2378        self.inner.offset = offset;
2379        self
2380    }
2381    pub fn range(mut self, range: DeviceSize) -> Self {
2382        self.inner.range = range;
2383        self
2384    }
2385    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2386    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2387    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2388    pub fn build(self) -> DescriptorBufferInfo {
2389        self.inner
2390    }
2391}
2392#[repr(C)]
2393#[cfg_attr(feature = "debug", derive(Debug))]
2394#[derive(Copy, Clone, Default)]
2395#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorImageInfo.html>"]
2396pub struct DescriptorImageInfo {
2397    pub sampler: Sampler,
2398    pub image_view: ImageView,
2399    pub image_layout: ImageLayout,
2400}
2401impl DescriptorImageInfo {
2402    pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> {
2403        DescriptorImageInfoBuilder {
2404            inner: Self::default(),
2405            marker: ::std::marker::PhantomData,
2406        }
2407    }
2408}
2409#[repr(transparent)]
2410pub struct DescriptorImageInfoBuilder<'a> {
2411    inner: DescriptorImageInfo,
2412    marker: ::std::marker::PhantomData<&'a ()>,
2413}
2414impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> {
2415    type Target = DescriptorImageInfo;
2416    fn deref(&self) -> &Self::Target {
2417        &self.inner
2418    }
2419}
2420impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> {
2421    fn deref_mut(&mut self) -> &mut Self::Target {
2422        &mut self.inner
2423    }
2424}
2425impl<'a> DescriptorImageInfoBuilder<'a> {
2426    pub fn sampler(mut self, sampler: Sampler) -> Self {
2427        self.inner.sampler = sampler;
2428        self
2429    }
2430    pub fn image_view(mut self, image_view: ImageView) -> Self {
2431        self.inner.image_view = image_view;
2432        self
2433    }
2434    pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
2435        self.inner.image_layout = image_layout;
2436        self
2437    }
2438    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2439    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2440    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2441    pub fn build(self) -> DescriptorImageInfo {
2442        self.inner
2443    }
2444}
2445#[repr(C)]
2446#[cfg_attr(feature = "debug", derive(Debug))]
2447#[derive(Copy, Clone)]
2448#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html>"]
2449pub struct WriteDescriptorSet {
2450    pub s_type: StructureType,
2451    pub p_next: *const c_void,
2452    pub dst_set: DescriptorSet,
2453    pub dst_binding: u32,
2454    pub dst_array_element: u32,
2455    pub descriptor_count: u32,
2456    pub descriptor_type: DescriptorType,
2457    pub p_image_info: *const DescriptorImageInfo,
2458    pub p_buffer_info: *const DescriptorBufferInfo,
2459    pub p_texel_buffer_view: *const BufferView,
2460}
2461impl ::std::default::Default for WriteDescriptorSet {
2462    fn default() -> Self {
2463        Self {
2464            s_type: StructureType::WRITE_DESCRIPTOR_SET,
2465            p_next: ::std::ptr::null(),
2466            dst_set: DescriptorSet::default(),
2467            dst_binding: u32::default(),
2468            dst_array_element: u32::default(),
2469            descriptor_count: u32::default(),
2470            descriptor_type: DescriptorType::default(),
2471            p_image_info: ::std::ptr::null(),
2472            p_buffer_info: ::std::ptr::null(),
2473            p_texel_buffer_view: ::std::ptr::null(),
2474        }
2475    }
2476}
2477impl WriteDescriptorSet {
2478    pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> {
2479        WriteDescriptorSetBuilder {
2480            inner: Self::default(),
2481            marker: ::std::marker::PhantomData,
2482        }
2483    }
2484}
2485#[repr(transparent)]
2486pub struct WriteDescriptorSetBuilder<'a> {
2487    inner: WriteDescriptorSet,
2488    marker: ::std::marker::PhantomData<&'a ()>,
2489}
2490pub unsafe trait ExtendsWriteDescriptorSet {}
2491impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> {
2492    type Target = WriteDescriptorSet;
2493    fn deref(&self) -> &Self::Target {
2494        &self.inner
2495    }
2496}
2497impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
2498    fn deref_mut(&mut self) -> &mut Self::Target {
2499        &mut self.inner
2500    }
2501}
2502impl<'a> WriteDescriptorSetBuilder<'a> {
2503    pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
2504        self.inner.dst_set = dst_set;
2505        self
2506    }
2507    pub fn dst_binding(mut self, dst_binding: u32) -> Self {
2508        self.inner.dst_binding = dst_binding;
2509        self
2510    }
2511    pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
2512        self.inner.dst_array_element = dst_array_element;
2513        self
2514    }
2515    pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
2516        self.inner.descriptor_type = descriptor_type;
2517        self
2518    }
2519    pub fn image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self {
2520        self.inner.descriptor_count = image_info.len() as _;
2521        self.inner.p_image_info = image_info.as_ptr();
2522        self
2523    }
2524    pub fn buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self {
2525        self.inner.descriptor_count = buffer_info.len() as _;
2526        self.inner.p_buffer_info = buffer_info.as_ptr();
2527        self
2528    }
2529    pub fn texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self {
2530        self.inner.descriptor_count = texel_buffer_view.len() as _;
2531        self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr();
2532        self
2533    }
2534    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2535    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2536    #[doc = r" valid extension structs can be pushed into the chain."]
2537    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2538    #[doc = r" chain will look like `A -> D -> B -> C`."]
2539    pub fn push_next<T: ExtendsWriteDescriptorSet>(mut self, next: &'a mut T) -> Self {
2540        unsafe {
2541            let next_ptr = <*const T>::cast(next);
2542            let last_next = ptr_chain_iter(next).last().unwrap();
2543            (*last_next).p_next = self.inner.p_next as _;
2544            self.inner.p_next = next_ptr;
2545        }
2546        self
2547    }
2548    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2549    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2550    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2551    pub fn build(self) -> WriteDescriptorSet {
2552        self.inner
2553    }
2554}
2555#[repr(C)]
2556#[cfg_attr(feature = "debug", derive(Debug))]
2557#[derive(Copy, Clone)]
2558#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyDescriptorSet.html>"]
2559pub struct CopyDescriptorSet {
2560    pub s_type: StructureType,
2561    pub p_next: *const c_void,
2562    pub src_set: DescriptorSet,
2563    pub src_binding: u32,
2564    pub src_array_element: u32,
2565    pub dst_set: DescriptorSet,
2566    pub dst_binding: u32,
2567    pub dst_array_element: u32,
2568    pub descriptor_count: u32,
2569}
2570impl ::std::default::Default for CopyDescriptorSet {
2571    fn default() -> Self {
2572        Self {
2573            s_type: StructureType::COPY_DESCRIPTOR_SET,
2574            p_next: ::std::ptr::null(),
2575            src_set: DescriptorSet::default(),
2576            src_binding: u32::default(),
2577            src_array_element: u32::default(),
2578            dst_set: DescriptorSet::default(),
2579            dst_binding: u32::default(),
2580            dst_array_element: u32::default(),
2581            descriptor_count: u32::default(),
2582        }
2583    }
2584}
2585impl CopyDescriptorSet {
2586    pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> {
2587        CopyDescriptorSetBuilder {
2588            inner: Self::default(),
2589            marker: ::std::marker::PhantomData,
2590        }
2591    }
2592}
2593#[repr(transparent)]
2594pub struct CopyDescriptorSetBuilder<'a> {
2595    inner: CopyDescriptorSet,
2596    marker: ::std::marker::PhantomData<&'a ()>,
2597}
2598impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> {
2599    type Target = CopyDescriptorSet;
2600    fn deref(&self) -> &Self::Target {
2601        &self.inner
2602    }
2603}
2604impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
2605    fn deref_mut(&mut self) -> &mut Self::Target {
2606        &mut self.inner
2607    }
2608}
2609impl<'a> CopyDescriptorSetBuilder<'a> {
2610    pub fn src_set(mut self, src_set: DescriptorSet) -> Self {
2611        self.inner.src_set = src_set;
2612        self
2613    }
2614    pub fn src_binding(mut self, src_binding: u32) -> Self {
2615        self.inner.src_binding = src_binding;
2616        self
2617    }
2618    pub fn src_array_element(mut self, src_array_element: u32) -> Self {
2619        self.inner.src_array_element = src_array_element;
2620        self
2621    }
2622    pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
2623        self.inner.dst_set = dst_set;
2624        self
2625    }
2626    pub fn dst_binding(mut self, dst_binding: u32) -> Self {
2627        self.inner.dst_binding = dst_binding;
2628        self
2629    }
2630    pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
2631        self.inner.dst_array_element = dst_array_element;
2632        self
2633    }
2634    pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
2635        self.inner.descriptor_count = descriptor_count;
2636        self
2637    }
2638    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2639    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2640    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2641    pub fn build(self) -> CopyDescriptorSet {
2642        self.inner
2643    }
2644}
2645#[repr(C)]
2646#[cfg_attr(feature = "debug", derive(Debug))]
2647#[derive(Copy, Clone)]
2648#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateInfo.html>"]
2649pub struct BufferCreateInfo {
2650    pub s_type: StructureType,
2651    pub p_next: *const c_void,
2652    pub flags: BufferCreateFlags,
2653    pub size: DeviceSize,
2654    pub usage: BufferUsageFlags,
2655    pub sharing_mode: SharingMode,
2656    pub queue_family_index_count: u32,
2657    pub p_queue_family_indices: *const u32,
2658}
2659impl ::std::default::Default for BufferCreateInfo {
2660    fn default() -> Self {
2661        Self {
2662            s_type: StructureType::BUFFER_CREATE_INFO,
2663            p_next: ::std::ptr::null(),
2664            flags: BufferCreateFlags::default(),
2665            size: DeviceSize::default(),
2666            usage: BufferUsageFlags::default(),
2667            sharing_mode: SharingMode::default(),
2668            queue_family_index_count: u32::default(),
2669            p_queue_family_indices: ::std::ptr::null(),
2670        }
2671    }
2672}
2673impl BufferCreateInfo {
2674    pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> {
2675        BufferCreateInfoBuilder {
2676            inner: Self::default(),
2677            marker: ::std::marker::PhantomData,
2678        }
2679    }
2680}
2681#[repr(transparent)]
2682pub struct BufferCreateInfoBuilder<'a> {
2683    inner: BufferCreateInfo,
2684    marker: ::std::marker::PhantomData<&'a ()>,
2685}
2686pub unsafe trait ExtendsBufferCreateInfo {}
2687impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> {
2688    type Target = BufferCreateInfo;
2689    fn deref(&self) -> &Self::Target {
2690        &self.inner
2691    }
2692}
2693impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> {
2694    fn deref_mut(&mut self) -> &mut Self::Target {
2695        &mut self.inner
2696    }
2697}
2698impl<'a> BufferCreateInfoBuilder<'a> {
2699    pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
2700        self.inner.flags = flags;
2701        self
2702    }
2703    pub fn size(mut self, size: DeviceSize) -> Self {
2704        self.inner.size = size;
2705        self
2706    }
2707    pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
2708        self.inner.usage = usage;
2709        self
2710    }
2711    pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
2712        self.inner.sharing_mode = sharing_mode;
2713        self
2714    }
2715    pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
2716        self.inner.queue_family_index_count = queue_family_indices.len() as _;
2717        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
2718        self
2719    }
2720    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2721    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2722    #[doc = r" valid extension structs can be pushed into the chain."]
2723    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2724    #[doc = r" chain will look like `A -> D -> B -> C`."]
2725    pub fn push_next<T: ExtendsBufferCreateInfo>(mut self, next: &'a mut T) -> Self {
2726        unsafe {
2727            let next_ptr = <*const T>::cast(next);
2728            let last_next = ptr_chain_iter(next).last().unwrap();
2729            (*last_next).p_next = self.inner.p_next as _;
2730            self.inner.p_next = next_ptr;
2731        }
2732        self
2733    }
2734    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2735    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2736    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2737    pub fn build(self) -> BufferCreateInfo {
2738        self.inner
2739    }
2740}
2741#[repr(C)]
2742#[cfg_attr(feature = "debug", derive(Debug))]
2743#[derive(Copy, Clone)]
2744#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateInfo.html>"]
2745pub struct BufferViewCreateInfo {
2746    pub s_type: StructureType,
2747    pub p_next: *const c_void,
2748    pub flags: BufferViewCreateFlags,
2749    pub buffer: Buffer,
2750    pub format: Format,
2751    pub offset: DeviceSize,
2752    pub range: DeviceSize,
2753}
2754impl ::std::default::Default for BufferViewCreateInfo {
2755    fn default() -> Self {
2756        Self {
2757            s_type: StructureType::BUFFER_VIEW_CREATE_INFO,
2758            p_next: ::std::ptr::null(),
2759            flags: BufferViewCreateFlags::default(),
2760            buffer: Buffer::default(),
2761            format: Format::default(),
2762            offset: DeviceSize::default(),
2763            range: DeviceSize::default(),
2764        }
2765    }
2766}
2767impl BufferViewCreateInfo {
2768    pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> {
2769        BufferViewCreateInfoBuilder {
2770            inner: Self::default(),
2771            marker: ::std::marker::PhantomData,
2772        }
2773    }
2774}
2775#[repr(transparent)]
2776pub struct BufferViewCreateInfoBuilder<'a> {
2777    inner: BufferViewCreateInfo,
2778    marker: ::std::marker::PhantomData<&'a ()>,
2779}
2780impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> {
2781    type Target = BufferViewCreateInfo;
2782    fn deref(&self) -> &Self::Target {
2783        &self.inner
2784    }
2785}
2786impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
2787    fn deref_mut(&mut self) -> &mut Self::Target {
2788        &mut self.inner
2789    }
2790}
2791impl<'a> BufferViewCreateInfoBuilder<'a> {
2792    pub fn flags(mut self, flags: BufferViewCreateFlags) -> Self {
2793        self.inner.flags = flags;
2794        self
2795    }
2796    pub fn buffer(mut self, buffer: Buffer) -> Self {
2797        self.inner.buffer = buffer;
2798        self
2799    }
2800    pub fn format(mut self, format: Format) -> Self {
2801        self.inner.format = format;
2802        self
2803    }
2804    pub fn offset(mut self, offset: DeviceSize) -> Self {
2805        self.inner.offset = offset;
2806        self
2807    }
2808    pub fn range(mut self, range: DeviceSize) -> Self {
2809        self.inner.range = range;
2810        self
2811    }
2812    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2813    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2814    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2815    pub fn build(self) -> BufferViewCreateInfo {
2816        self.inner
2817    }
2818}
2819#[repr(C)]
2820#[cfg_attr(feature = "debug", derive(Debug))]
2821#[derive(Copy, Clone, Default)]
2822#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource.html>"]
2823pub struct ImageSubresource {
2824    pub aspect_mask: ImageAspectFlags,
2825    pub mip_level: u32,
2826    pub array_layer: u32,
2827}
2828impl ImageSubresource {
2829    pub fn builder<'a>() -> ImageSubresourceBuilder<'a> {
2830        ImageSubresourceBuilder {
2831            inner: Self::default(),
2832            marker: ::std::marker::PhantomData,
2833        }
2834    }
2835}
2836#[repr(transparent)]
2837pub struct ImageSubresourceBuilder<'a> {
2838    inner: ImageSubresource,
2839    marker: ::std::marker::PhantomData<&'a ()>,
2840}
2841impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> {
2842    type Target = ImageSubresource;
2843    fn deref(&self) -> &Self::Target {
2844        &self.inner
2845    }
2846}
2847impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> {
2848    fn deref_mut(&mut self) -> &mut Self::Target {
2849        &mut self.inner
2850    }
2851}
2852impl<'a> ImageSubresourceBuilder<'a> {
2853    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
2854        self.inner.aspect_mask = aspect_mask;
2855        self
2856    }
2857    pub fn mip_level(mut self, mip_level: u32) -> Self {
2858        self.inner.mip_level = mip_level;
2859        self
2860    }
2861    pub fn array_layer(mut self, array_layer: u32) -> Self {
2862        self.inner.array_layer = array_layer;
2863        self
2864    }
2865    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2866    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2867    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2868    pub fn build(self) -> ImageSubresource {
2869        self.inner
2870    }
2871}
2872#[repr(C)]
2873#[cfg_attr(feature = "debug", derive(Debug))]
2874#[derive(Copy, Clone, Default)]
2875#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceLayers.html>"]
2876pub struct ImageSubresourceLayers {
2877    pub aspect_mask: ImageAspectFlags,
2878    pub mip_level: u32,
2879    pub base_array_layer: u32,
2880    pub layer_count: u32,
2881}
2882impl ImageSubresourceLayers {
2883    pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> {
2884        ImageSubresourceLayersBuilder {
2885            inner: Self::default(),
2886            marker: ::std::marker::PhantomData,
2887        }
2888    }
2889}
2890#[repr(transparent)]
2891pub struct ImageSubresourceLayersBuilder<'a> {
2892    inner: ImageSubresourceLayers,
2893    marker: ::std::marker::PhantomData<&'a ()>,
2894}
2895impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> {
2896    type Target = ImageSubresourceLayers;
2897    fn deref(&self) -> &Self::Target {
2898        &self.inner
2899    }
2900}
2901impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> {
2902    fn deref_mut(&mut self) -> &mut Self::Target {
2903        &mut self.inner
2904    }
2905}
2906impl<'a> ImageSubresourceLayersBuilder<'a> {
2907    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
2908        self.inner.aspect_mask = aspect_mask;
2909        self
2910    }
2911    pub fn mip_level(mut self, mip_level: u32) -> Self {
2912        self.inner.mip_level = mip_level;
2913        self
2914    }
2915    pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
2916        self.inner.base_array_layer = base_array_layer;
2917        self
2918    }
2919    pub fn layer_count(mut self, layer_count: u32) -> Self {
2920        self.inner.layer_count = layer_count;
2921        self
2922    }
2923    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2924    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2925    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2926    pub fn build(self) -> ImageSubresourceLayers {
2927        self.inner
2928    }
2929}
2930#[repr(C)]
2931#[cfg_attr(feature = "debug", derive(Debug))]
2932#[derive(Copy, Clone, Default)]
2933#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceRange.html>"]
2934pub struct ImageSubresourceRange {
2935    pub aspect_mask: ImageAspectFlags,
2936    pub base_mip_level: u32,
2937    pub level_count: u32,
2938    pub base_array_layer: u32,
2939    pub layer_count: u32,
2940}
2941impl ImageSubresourceRange {
2942    pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> {
2943        ImageSubresourceRangeBuilder {
2944            inner: Self::default(),
2945            marker: ::std::marker::PhantomData,
2946        }
2947    }
2948}
2949#[repr(transparent)]
2950pub struct ImageSubresourceRangeBuilder<'a> {
2951    inner: ImageSubresourceRange,
2952    marker: ::std::marker::PhantomData<&'a ()>,
2953}
2954impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> {
2955    type Target = ImageSubresourceRange;
2956    fn deref(&self) -> &Self::Target {
2957        &self.inner
2958    }
2959}
2960impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> {
2961    fn deref_mut(&mut self) -> &mut Self::Target {
2962        &mut self.inner
2963    }
2964}
2965impl<'a> ImageSubresourceRangeBuilder<'a> {
2966    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
2967        self.inner.aspect_mask = aspect_mask;
2968        self
2969    }
2970    pub fn base_mip_level(mut self, base_mip_level: u32) -> Self {
2971        self.inner.base_mip_level = base_mip_level;
2972        self
2973    }
2974    pub fn level_count(mut self, level_count: u32) -> Self {
2975        self.inner.level_count = level_count;
2976        self
2977    }
2978    pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
2979        self.inner.base_array_layer = base_array_layer;
2980        self
2981    }
2982    pub fn layer_count(mut self, layer_count: u32) -> Self {
2983        self.inner.layer_count = layer_count;
2984        self
2985    }
2986    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2987    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2988    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
2989    pub fn build(self) -> ImageSubresourceRange {
2990        self.inner
2991    }
2992}
2993#[repr(C)]
2994#[cfg_attr(feature = "debug", derive(Debug))]
2995#[derive(Copy, Clone)]
2996#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier.html>"]
2997pub struct MemoryBarrier {
2998    pub s_type: StructureType,
2999    pub p_next: *const c_void,
3000    pub src_access_mask: AccessFlags,
3001    pub dst_access_mask: AccessFlags,
3002}
3003impl ::std::default::Default for MemoryBarrier {
3004    fn default() -> Self {
3005        Self {
3006            s_type: StructureType::MEMORY_BARRIER,
3007            p_next: ::std::ptr::null(),
3008            src_access_mask: AccessFlags::default(),
3009            dst_access_mask: AccessFlags::default(),
3010        }
3011    }
3012}
3013impl MemoryBarrier {
3014    pub fn builder<'a>() -> MemoryBarrierBuilder<'a> {
3015        MemoryBarrierBuilder {
3016            inner: Self::default(),
3017            marker: ::std::marker::PhantomData,
3018        }
3019    }
3020}
3021#[repr(transparent)]
3022pub struct MemoryBarrierBuilder<'a> {
3023    inner: MemoryBarrier,
3024    marker: ::std::marker::PhantomData<&'a ()>,
3025}
3026impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> {
3027    type Target = MemoryBarrier;
3028    fn deref(&self) -> &Self::Target {
3029        &self.inner
3030    }
3031}
3032impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> {
3033    fn deref_mut(&mut self) -> &mut Self::Target {
3034        &mut self.inner
3035    }
3036}
3037impl<'a> MemoryBarrierBuilder<'a> {
3038    pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3039        self.inner.src_access_mask = src_access_mask;
3040        self
3041    }
3042    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3043        self.inner.dst_access_mask = dst_access_mask;
3044        self
3045    }
3046    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3047    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3048    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3049    pub fn build(self) -> MemoryBarrier {
3050        self.inner
3051    }
3052}
3053#[repr(C)]
3054#[cfg_attr(feature = "debug", derive(Debug))]
3055#[derive(Copy, Clone)]
3056#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier.html>"]
3057pub struct BufferMemoryBarrier {
3058    pub s_type: StructureType,
3059    pub p_next: *const c_void,
3060    pub src_access_mask: AccessFlags,
3061    pub dst_access_mask: AccessFlags,
3062    pub src_queue_family_index: u32,
3063    pub dst_queue_family_index: u32,
3064    pub buffer: Buffer,
3065    pub offset: DeviceSize,
3066    pub size: DeviceSize,
3067}
3068impl ::std::default::Default for BufferMemoryBarrier {
3069    fn default() -> Self {
3070        Self {
3071            s_type: StructureType::BUFFER_MEMORY_BARRIER,
3072            p_next: ::std::ptr::null(),
3073            src_access_mask: AccessFlags::default(),
3074            dst_access_mask: AccessFlags::default(),
3075            src_queue_family_index: u32::default(),
3076            dst_queue_family_index: u32::default(),
3077            buffer: Buffer::default(),
3078            offset: DeviceSize::default(),
3079            size: DeviceSize::default(),
3080        }
3081    }
3082}
3083impl BufferMemoryBarrier {
3084    pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> {
3085        BufferMemoryBarrierBuilder {
3086            inner: Self::default(),
3087            marker: ::std::marker::PhantomData,
3088        }
3089    }
3090}
3091#[repr(transparent)]
3092pub struct BufferMemoryBarrierBuilder<'a> {
3093    inner: BufferMemoryBarrier,
3094    marker: ::std::marker::PhantomData<&'a ()>,
3095}
3096impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> {
3097    type Target = BufferMemoryBarrier;
3098    fn deref(&self) -> &Self::Target {
3099        &self.inner
3100    }
3101}
3102impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
3103    fn deref_mut(&mut self) -> &mut Self::Target {
3104        &mut self.inner
3105    }
3106}
3107impl<'a> BufferMemoryBarrierBuilder<'a> {
3108    pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3109        self.inner.src_access_mask = src_access_mask;
3110        self
3111    }
3112    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3113        self.inner.dst_access_mask = dst_access_mask;
3114        self
3115    }
3116    pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
3117        self.inner.src_queue_family_index = src_queue_family_index;
3118        self
3119    }
3120    pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
3121        self.inner.dst_queue_family_index = dst_queue_family_index;
3122        self
3123    }
3124    pub fn buffer(mut self, buffer: Buffer) -> Self {
3125        self.inner.buffer = buffer;
3126        self
3127    }
3128    pub fn offset(mut self, offset: DeviceSize) -> Self {
3129        self.inner.offset = offset;
3130        self
3131    }
3132    pub fn size(mut self, size: DeviceSize) -> Self {
3133        self.inner.size = size;
3134        self
3135    }
3136    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3137    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3138    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3139    pub fn build(self) -> BufferMemoryBarrier {
3140        self.inner
3141    }
3142}
3143#[repr(C)]
3144#[cfg_attr(feature = "debug", derive(Debug))]
3145#[derive(Copy, Clone)]
3146#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier.html>"]
3147pub struct ImageMemoryBarrier {
3148    pub s_type: StructureType,
3149    pub p_next: *const c_void,
3150    pub src_access_mask: AccessFlags,
3151    pub dst_access_mask: AccessFlags,
3152    pub old_layout: ImageLayout,
3153    pub new_layout: ImageLayout,
3154    pub src_queue_family_index: u32,
3155    pub dst_queue_family_index: u32,
3156    pub image: Image,
3157    pub subresource_range: ImageSubresourceRange,
3158}
3159impl ::std::default::Default for ImageMemoryBarrier {
3160    fn default() -> Self {
3161        Self {
3162            s_type: StructureType::IMAGE_MEMORY_BARRIER,
3163            p_next: ::std::ptr::null(),
3164            src_access_mask: AccessFlags::default(),
3165            dst_access_mask: AccessFlags::default(),
3166            old_layout: ImageLayout::default(),
3167            new_layout: ImageLayout::default(),
3168            src_queue_family_index: u32::default(),
3169            dst_queue_family_index: u32::default(),
3170            image: Image::default(),
3171            subresource_range: ImageSubresourceRange::default(),
3172        }
3173    }
3174}
3175impl ImageMemoryBarrier {
3176    pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> {
3177        ImageMemoryBarrierBuilder {
3178            inner: Self::default(),
3179            marker: ::std::marker::PhantomData,
3180        }
3181    }
3182}
3183#[repr(transparent)]
3184pub struct ImageMemoryBarrierBuilder<'a> {
3185    inner: ImageMemoryBarrier,
3186    marker: ::std::marker::PhantomData<&'a ()>,
3187}
3188pub unsafe trait ExtendsImageMemoryBarrier {}
3189impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> {
3190    type Target = ImageMemoryBarrier;
3191    fn deref(&self) -> &Self::Target {
3192        &self.inner
3193    }
3194}
3195impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
3196    fn deref_mut(&mut self) -> &mut Self::Target {
3197        &mut self.inner
3198    }
3199}
3200impl<'a> ImageMemoryBarrierBuilder<'a> {
3201    pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
3202        self.inner.src_access_mask = src_access_mask;
3203        self
3204    }
3205    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
3206        self.inner.dst_access_mask = dst_access_mask;
3207        self
3208    }
3209    pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
3210        self.inner.old_layout = old_layout;
3211        self
3212    }
3213    pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
3214        self.inner.new_layout = new_layout;
3215        self
3216    }
3217    pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
3218        self.inner.src_queue_family_index = src_queue_family_index;
3219        self
3220    }
3221    pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
3222        self.inner.dst_queue_family_index = dst_queue_family_index;
3223        self
3224    }
3225    pub fn image(mut self, image: Image) -> Self {
3226        self.inner.image = image;
3227        self
3228    }
3229    pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
3230        self.inner.subresource_range = subresource_range;
3231        self
3232    }
3233    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3234    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3235    #[doc = r" valid extension structs can be pushed into the chain."]
3236    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3237    #[doc = r" chain will look like `A -> D -> B -> C`."]
3238    pub fn push_next<T: ExtendsImageMemoryBarrier>(mut self, next: &'a mut T) -> Self {
3239        unsafe {
3240            let next_ptr = <*const T>::cast(next);
3241            let last_next = ptr_chain_iter(next).last().unwrap();
3242            (*last_next).p_next = self.inner.p_next as _;
3243            self.inner.p_next = next_ptr;
3244        }
3245        self
3246    }
3247    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3248    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3249    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3250    pub fn build(self) -> ImageMemoryBarrier {
3251        self.inner
3252    }
3253}
3254#[repr(C)]
3255#[cfg_attr(feature = "debug", derive(Debug))]
3256#[derive(Copy, Clone)]
3257#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateInfo.html>"]
3258pub struct ImageCreateInfo {
3259    pub s_type: StructureType,
3260    pub p_next: *const c_void,
3261    pub flags: ImageCreateFlags,
3262    pub image_type: ImageType,
3263    pub format: Format,
3264    pub extent: Extent3D,
3265    pub mip_levels: u32,
3266    pub array_layers: u32,
3267    pub samples: SampleCountFlags,
3268    pub tiling: ImageTiling,
3269    pub usage: ImageUsageFlags,
3270    pub sharing_mode: SharingMode,
3271    pub queue_family_index_count: u32,
3272    pub p_queue_family_indices: *const u32,
3273    pub initial_layout: ImageLayout,
3274}
3275impl ::std::default::Default for ImageCreateInfo {
3276    fn default() -> Self {
3277        Self {
3278            s_type: StructureType::IMAGE_CREATE_INFO,
3279            p_next: ::std::ptr::null(),
3280            flags: ImageCreateFlags::default(),
3281            image_type: ImageType::default(),
3282            format: Format::default(),
3283            extent: Extent3D::default(),
3284            mip_levels: u32::default(),
3285            array_layers: u32::default(),
3286            samples: SampleCountFlags::default(),
3287            tiling: ImageTiling::default(),
3288            usage: ImageUsageFlags::default(),
3289            sharing_mode: SharingMode::default(),
3290            queue_family_index_count: u32::default(),
3291            p_queue_family_indices: ::std::ptr::null(),
3292            initial_layout: ImageLayout::default(),
3293        }
3294    }
3295}
3296impl ImageCreateInfo {
3297    pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> {
3298        ImageCreateInfoBuilder {
3299            inner: Self::default(),
3300            marker: ::std::marker::PhantomData,
3301        }
3302    }
3303}
3304#[repr(transparent)]
3305pub struct ImageCreateInfoBuilder<'a> {
3306    inner: ImageCreateInfo,
3307    marker: ::std::marker::PhantomData<&'a ()>,
3308}
3309pub unsafe trait ExtendsImageCreateInfo {}
3310impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> {
3311    type Target = ImageCreateInfo;
3312    fn deref(&self) -> &Self::Target {
3313        &self.inner
3314    }
3315}
3316impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> {
3317    fn deref_mut(&mut self) -> &mut Self::Target {
3318        &mut self.inner
3319    }
3320}
3321impl<'a> ImageCreateInfoBuilder<'a> {
3322    pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
3323        self.inner.flags = flags;
3324        self
3325    }
3326    pub fn image_type(mut self, image_type: ImageType) -> Self {
3327        self.inner.image_type = image_type;
3328        self
3329    }
3330    pub fn format(mut self, format: Format) -> Self {
3331        self.inner.format = format;
3332        self
3333    }
3334    pub fn extent(mut self, extent: Extent3D) -> Self {
3335        self.inner.extent = extent;
3336        self
3337    }
3338    pub fn mip_levels(mut self, mip_levels: u32) -> Self {
3339        self.inner.mip_levels = mip_levels;
3340        self
3341    }
3342    pub fn array_layers(mut self, array_layers: u32) -> Self {
3343        self.inner.array_layers = array_layers;
3344        self
3345    }
3346    pub fn samples(mut self, samples: SampleCountFlags) -> Self {
3347        self.inner.samples = samples;
3348        self
3349    }
3350    pub fn tiling(mut self, tiling: ImageTiling) -> Self {
3351        self.inner.tiling = tiling;
3352        self
3353    }
3354    pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
3355        self.inner.usage = usage;
3356        self
3357    }
3358    pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
3359        self.inner.sharing_mode = sharing_mode;
3360        self
3361    }
3362    pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
3363        self.inner.queue_family_index_count = queue_family_indices.len() as _;
3364        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
3365        self
3366    }
3367    pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
3368        self.inner.initial_layout = initial_layout;
3369        self
3370    }
3371    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3372    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3373    #[doc = r" valid extension structs can be pushed into the chain."]
3374    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3375    #[doc = r" chain will look like `A -> D -> B -> C`."]
3376    pub fn push_next<T: ExtendsImageCreateInfo>(mut self, next: &'a mut T) -> Self {
3377        unsafe {
3378            let next_ptr = <*const T>::cast(next);
3379            let last_next = ptr_chain_iter(next).last().unwrap();
3380            (*last_next).p_next = self.inner.p_next as _;
3381            self.inner.p_next = next_ptr;
3382        }
3383        self
3384    }
3385    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3386    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3387    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3388    pub fn build(self) -> ImageCreateInfo {
3389        self.inner
3390    }
3391}
3392#[repr(C)]
3393#[cfg_attr(feature = "debug", derive(Debug))]
3394#[derive(Copy, Clone, Default)]
3395#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout.html>"]
3396pub struct SubresourceLayout {
3397    pub offset: DeviceSize,
3398    pub size: DeviceSize,
3399    pub row_pitch: DeviceSize,
3400    pub array_pitch: DeviceSize,
3401    pub depth_pitch: DeviceSize,
3402}
3403impl SubresourceLayout {
3404    pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> {
3405        SubresourceLayoutBuilder {
3406            inner: Self::default(),
3407            marker: ::std::marker::PhantomData,
3408        }
3409    }
3410}
3411#[repr(transparent)]
3412pub struct SubresourceLayoutBuilder<'a> {
3413    inner: SubresourceLayout,
3414    marker: ::std::marker::PhantomData<&'a ()>,
3415}
3416impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> {
3417    type Target = SubresourceLayout;
3418    fn deref(&self) -> &Self::Target {
3419        &self.inner
3420    }
3421}
3422impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> {
3423    fn deref_mut(&mut self) -> &mut Self::Target {
3424        &mut self.inner
3425    }
3426}
3427impl<'a> SubresourceLayoutBuilder<'a> {
3428    pub fn offset(mut self, offset: DeviceSize) -> Self {
3429        self.inner.offset = offset;
3430        self
3431    }
3432    pub fn size(mut self, size: DeviceSize) -> Self {
3433        self.inner.size = size;
3434        self
3435    }
3436    pub fn row_pitch(mut self, row_pitch: DeviceSize) -> Self {
3437        self.inner.row_pitch = row_pitch;
3438        self
3439    }
3440    pub fn array_pitch(mut self, array_pitch: DeviceSize) -> Self {
3441        self.inner.array_pitch = array_pitch;
3442        self
3443    }
3444    pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> Self {
3445        self.inner.depth_pitch = depth_pitch;
3446        self
3447    }
3448    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3449    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3450    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3451    pub fn build(self) -> SubresourceLayout {
3452        self.inner
3453    }
3454}
3455#[repr(C)]
3456#[cfg_attr(feature = "debug", derive(Debug))]
3457#[derive(Copy, Clone)]
3458#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateInfo.html>"]
3459pub struct ImageViewCreateInfo {
3460    pub s_type: StructureType,
3461    pub p_next: *const c_void,
3462    pub flags: ImageViewCreateFlags,
3463    pub image: Image,
3464    pub view_type: ImageViewType,
3465    pub format: Format,
3466    pub components: ComponentMapping,
3467    pub subresource_range: ImageSubresourceRange,
3468}
3469impl ::std::default::Default for ImageViewCreateInfo {
3470    fn default() -> Self {
3471        Self {
3472            s_type: StructureType::IMAGE_VIEW_CREATE_INFO,
3473            p_next: ::std::ptr::null(),
3474            flags: ImageViewCreateFlags::default(),
3475            image: Image::default(),
3476            view_type: ImageViewType::default(),
3477            format: Format::default(),
3478            components: ComponentMapping::default(),
3479            subresource_range: ImageSubresourceRange::default(),
3480        }
3481    }
3482}
3483impl ImageViewCreateInfo {
3484    pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> {
3485        ImageViewCreateInfoBuilder {
3486            inner: Self::default(),
3487            marker: ::std::marker::PhantomData,
3488        }
3489    }
3490}
3491#[repr(transparent)]
3492pub struct ImageViewCreateInfoBuilder<'a> {
3493    inner: ImageViewCreateInfo,
3494    marker: ::std::marker::PhantomData<&'a ()>,
3495}
3496pub unsafe trait ExtendsImageViewCreateInfo {}
3497impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> {
3498    type Target = ImageViewCreateInfo;
3499    fn deref(&self) -> &Self::Target {
3500        &self.inner
3501    }
3502}
3503impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
3504    fn deref_mut(&mut self) -> &mut Self::Target {
3505        &mut self.inner
3506    }
3507}
3508impl<'a> ImageViewCreateInfoBuilder<'a> {
3509    pub fn flags(mut self, flags: ImageViewCreateFlags) -> Self {
3510        self.inner.flags = flags;
3511        self
3512    }
3513    pub fn image(mut self, image: Image) -> Self {
3514        self.inner.image = image;
3515        self
3516    }
3517    pub fn view_type(mut self, view_type: ImageViewType) -> Self {
3518        self.inner.view_type = view_type;
3519        self
3520    }
3521    pub fn format(mut self, format: Format) -> Self {
3522        self.inner.format = format;
3523        self
3524    }
3525    pub fn components(mut self, components: ComponentMapping) -> Self {
3526        self.inner.components = components;
3527        self
3528    }
3529    pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
3530        self.inner.subresource_range = subresource_range;
3531        self
3532    }
3533    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3534    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3535    #[doc = r" valid extension structs can be pushed into the chain."]
3536    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3537    #[doc = r" chain will look like `A -> D -> B -> C`."]
3538    pub fn push_next<T: ExtendsImageViewCreateInfo>(mut self, next: &'a mut T) -> Self {
3539        unsafe {
3540            let next_ptr = <*const T>::cast(next);
3541            let last_next = ptr_chain_iter(next).last().unwrap();
3542            (*last_next).p_next = self.inner.p_next as _;
3543            self.inner.p_next = next_ptr;
3544        }
3545        self
3546    }
3547    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3548    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3549    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3550    pub fn build(self) -> ImageViewCreateInfo {
3551        self.inner
3552    }
3553}
3554#[repr(C)]
3555#[cfg_attr(feature = "debug", derive(Debug))]
3556#[derive(Copy, Clone, Default)]
3557#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy.html>"]
3558pub struct BufferCopy {
3559    pub src_offset: DeviceSize,
3560    pub dst_offset: DeviceSize,
3561    pub size: DeviceSize,
3562}
3563impl BufferCopy {
3564    pub fn builder<'a>() -> BufferCopyBuilder<'a> {
3565        BufferCopyBuilder {
3566            inner: Self::default(),
3567            marker: ::std::marker::PhantomData,
3568        }
3569    }
3570}
3571#[repr(transparent)]
3572pub struct BufferCopyBuilder<'a> {
3573    inner: BufferCopy,
3574    marker: ::std::marker::PhantomData<&'a ()>,
3575}
3576impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> {
3577    type Target = BufferCopy;
3578    fn deref(&self) -> &Self::Target {
3579        &self.inner
3580    }
3581}
3582impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> {
3583    fn deref_mut(&mut self) -> &mut Self::Target {
3584        &mut self.inner
3585    }
3586}
3587impl<'a> BufferCopyBuilder<'a> {
3588    pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
3589        self.inner.src_offset = src_offset;
3590        self
3591    }
3592    pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
3593        self.inner.dst_offset = dst_offset;
3594        self
3595    }
3596    pub fn size(mut self, size: DeviceSize) -> Self {
3597        self.inner.size = size;
3598        self
3599    }
3600    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3601    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3602    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3603    pub fn build(self) -> BufferCopy {
3604        self.inner
3605    }
3606}
3607#[repr(C)]
3608#[cfg_attr(feature = "debug", derive(Debug))]
3609#[derive(Copy, Clone, Default)]
3610#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBind.html>"]
3611pub struct SparseMemoryBind {
3612    pub resource_offset: DeviceSize,
3613    pub size: DeviceSize,
3614    pub memory: DeviceMemory,
3615    pub memory_offset: DeviceSize,
3616    pub flags: SparseMemoryBindFlags,
3617}
3618impl SparseMemoryBind {
3619    pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> {
3620        SparseMemoryBindBuilder {
3621            inner: Self::default(),
3622            marker: ::std::marker::PhantomData,
3623        }
3624    }
3625}
3626#[repr(transparent)]
3627pub struct SparseMemoryBindBuilder<'a> {
3628    inner: SparseMemoryBind,
3629    marker: ::std::marker::PhantomData<&'a ()>,
3630}
3631impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> {
3632    type Target = SparseMemoryBind;
3633    fn deref(&self) -> &Self::Target {
3634        &self.inner
3635    }
3636}
3637impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> {
3638    fn deref_mut(&mut self) -> &mut Self::Target {
3639        &mut self.inner
3640    }
3641}
3642impl<'a> SparseMemoryBindBuilder<'a> {
3643    pub fn resource_offset(mut self, resource_offset: DeviceSize) -> Self {
3644        self.inner.resource_offset = resource_offset;
3645        self
3646    }
3647    pub fn size(mut self, size: DeviceSize) -> Self {
3648        self.inner.size = size;
3649        self
3650    }
3651    pub fn memory(mut self, memory: DeviceMemory) -> Self {
3652        self.inner.memory = memory;
3653        self
3654    }
3655    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
3656        self.inner.memory_offset = memory_offset;
3657        self
3658    }
3659    pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
3660        self.inner.flags = flags;
3661        self
3662    }
3663    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3664    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3665    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3666    pub fn build(self) -> SparseMemoryBind {
3667        self.inner
3668    }
3669}
3670#[repr(C)]
3671#[cfg_attr(feature = "debug", derive(Debug))]
3672#[derive(Copy, Clone, Default)]
3673#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBind.html>"]
3674pub struct SparseImageMemoryBind {
3675    pub subresource: ImageSubresource,
3676    pub offset: Offset3D,
3677    pub extent: Extent3D,
3678    pub memory: DeviceMemory,
3679    pub memory_offset: DeviceSize,
3680    pub flags: SparseMemoryBindFlags,
3681}
3682impl SparseImageMemoryBind {
3683    pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> {
3684        SparseImageMemoryBindBuilder {
3685            inner: Self::default(),
3686            marker: ::std::marker::PhantomData,
3687        }
3688    }
3689}
3690#[repr(transparent)]
3691pub struct SparseImageMemoryBindBuilder<'a> {
3692    inner: SparseImageMemoryBind,
3693    marker: ::std::marker::PhantomData<&'a ()>,
3694}
3695impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> {
3696    type Target = SparseImageMemoryBind;
3697    fn deref(&self) -> &Self::Target {
3698        &self.inner
3699    }
3700}
3701impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> {
3702    fn deref_mut(&mut self) -> &mut Self::Target {
3703        &mut self.inner
3704    }
3705}
3706impl<'a> SparseImageMemoryBindBuilder<'a> {
3707    pub fn subresource(mut self, subresource: ImageSubresource) -> Self {
3708        self.inner.subresource = subresource;
3709        self
3710    }
3711    pub fn offset(mut self, offset: Offset3D) -> Self {
3712        self.inner.offset = offset;
3713        self
3714    }
3715    pub fn extent(mut self, extent: Extent3D) -> Self {
3716        self.inner.extent = extent;
3717        self
3718    }
3719    pub fn memory(mut self, memory: DeviceMemory) -> Self {
3720        self.inner.memory = memory;
3721        self
3722    }
3723    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
3724        self.inner.memory_offset = memory_offset;
3725        self
3726    }
3727    pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
3728        self.inner.flags = flags;
3729        self
3730    }
3731    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3732    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3733    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3734    pub fn build(self) -> SparseImageMemoryBind {
3735        self.inner
3736    }
3737}
3738#[repr(C)]
3739#[cfg_attr(feature = "debug", derive(Debug))]
3740#[derive(Copy, Clone)]
3741#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseBufferMemoryBindInfo.html>"]
3742pub struct SparseBufferMemoryBindInfo {
3743    pub buffer: Buffer,
3744    pub bind_count: u32,
3745    pub p_binds: *const SparseMemoryBind,
3746}
3747impl ::std::default::Default for SparseBufferMemoryBindInfo {
3748    fn default() -> Self {
3749        Self {
3750            buffer: Buffer::default(),
3751            bind_count: u32::default(),
3752            p_binds: ::std::ptr::null(),
3753        }
3754    }
3755}
3756impl SparseBufferMemoryBindInfo {
3757    pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> {
3758        SparseBufferMemoryBindInfoBuilder {
3759            inner: Self::default(),
3760            marker: ::std::marker::PhantomData,
3761        }
3762    }
3763}
3764#[repr(transparent)]
3765pub struct SparseBufferMemoryBindInfoBuilder<'a> {
3766    inner: SparseBufferMemoryBindInfo,
3767    marker: ::std::marker::PhantomData<&'a ()>,
3768}
3769impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> {
3770    type Target = SparseBufferMemoryBindInfo;
3771    fn deref(&self) -> &Self::Target {
3772        &self.inner
3773    }
3774}
3775impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
3776    fn deref_mut(&mut self) -> &mut Self::Target {
3777        &mut self.inner
3778    }
3779}
3780impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
3781    pub fn buffer(mut self, buffer: Buffer) -> Self {
3782        self.inner.buffer = buffer;
3783        self
3784    }
3785    pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
3786        self.inner.bind_count = binds.len() as _;
3787        self.inner.p_binds = binds.as_ptr();
3788        self
3789    }
3790    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3791    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3792    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3793    pub fn build(self) -> SparseBufferMemoryBindInfo {
3794        self.inner
3795    }
3796}
3797#[repr(C)]
3798#[cfg_attr(feature = "debug", derive(Debug))]
3799#[derive(Copy, Clone)]
3800#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html>"]
3801pub struct SparseImageOpaqueMemoryBindInfo {
3802    pub image: Image,
3803    pub bind_count: u32,
3804    pub p_binds: *const SparseMemoryBind,
3805}
3806impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo {
3807    fn default() -> Self {
3808        Self {
3809            image: Image::default(),
3810            bind_count: u32::default(),
3811            p_binds: ::std::ptr::null(),
3812        }
3813    }
3814}
3815impl SparseImageOpaqueMemoryBindInfo {
3816    pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3817        SparseImageOpaqueMemoryBindInfoBuilder {
3818            inner: Self::default(),
3819            marker: ::std::marker::PhantomData,
3820        }
3821    }
3822}
3823#[repr(transparent)]
3824pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3825    inner: SparseImageOpaqueMemoryBindInfo,
3826    marker: ::std::marker::PhantomData<&'a ()>,
3827}
3828impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3829    type Target = SparseImageOpaqueMemoryBindInfo;
3830    fn deref(&self) -> &Self::Target {
3831        &self.inner
3832    }
3833}
3834impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3835    fn deref_mut(&mut self) -> &mut Self::Target {
3836        &mut self.inner
3837    }
3838}
3839impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
3840    pub fn image(mut self, image: Image) -> Self {
3841        self.inner.image = image;
3842        self
3843    }
3844    pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
3845        self.inner.bind_count = binds.len() as _;
3846        self.inner.p_binds = binds.as_ptr();
3847        self
3848    }
3849    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3850    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3851    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3852    pub fn build(self) -> SparseImageOpaqueMemoryBindInfo {
3853        self.inner
3854    }
3855}
3856#[repr(C)]
3857#[cfg_attr(feature = "debug", derive(Debug))]
3858#[derive(Copy, Clone)]
3859#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBindInfo.html>"]
3860pub struct SparseImageMemoryBindInfo {
3861    pub image: Image,
3862    pub bind_count: u32,
3863    pub p_binds: *const SparseImageMemoryBind,
3864}
3865impl ::std::default::Default for SparseImageMemoryBindInfo {
3866    fn default() -> Self {
3867        Self {
3868            image: Image::default(),
3869            bind_count: u32::default(),
3870            p_binds: ::std::ptr::null(),
3871        }
3872    }
3873}
3874impl SparseImageMemoryBindInfo {
3875    pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> {
3876        SparseImageMemoryBindInfoBuilder {
3877            inner: Self::default(),
3878            marker: ::std::marker::PhantomData,
3879        }
3880    }
3881}
3882#[repr(transparent)]
3883pub struct SparseImageMemoryBindInfoBuilder<'a> {
3884    inner: SparseImageMemoryBindInfo,
3885    marker: ::std::marker::PhantomData<&'a ()>,
3886}
3887impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> {
3888    type Target = SparseImageMemoryBindInfo;
3889    fn deref(&self) -> &Self::Target {
3890        &self.inner
3891    }
3892}
3893impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
3894    fn deref_mut(&mut self) -> &mut Self::Target {
3895        &mut self.inner
3896    }
3897}
3898impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
3899    pub fn image(mut self, image: Image) -> Self {
3900        self.inner.image = image;
3901        self
3902    }
3903    pub fn binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self {
3904        self.inner.bind_count = binds.len() as _;
3905        self.inner.p_binds = binds.as_ptr();
3906        self
3907    }
3908    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3909    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3910    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
3911    pub fn build(self) -> SparseImageMemoryBindInfo {
3912        self.inner
3913    }
3914}
3915#[repr(C)]
3916#[cfg_attr(feature = "debug", derive(Debug))]
3917#[derive(Copy, Clone)]
3918#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindSparseInfo.html>"]
3919pub struct BindSparseInfo {
3920    pub s_type: StructureType,
3921    pub p_next: *const c_void,
3922    pub wait_semaphore_count: u32,
3923    pub p_wait_semaphores: *const Semaphore,
3924    pub buffer_bind_count: u32,
3925    pub p_buffer_binds: *const SparseBufferMemoryBindInfo,
3926    pub image_opaque_bind_count: u32,
3927    pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo,
3928    pub image_bind_count: u32,
3929    pub p_image_binds: *const SparseImageMemoryBindInfo,
3930    pub signal_semaphore_count: u32,
3931    pub p_signal_semaphores: *const Semaphore,
3932}
3933impl ::std::default::Default for BindSparseInfo {
3934    fn default() -> Self {
3935        Self {
3936            s_type: StructureType::BIND_SPARSE_INFO,
3937            p_next: ::std::ptr::null(),
3938            wait_semaphore_count: u32::default(),
3939            p_wait_semaphores: ::std::ptr::null(),
3940            buffer_bind_count: u32::default(),
3941            p_buffer_binds: ::std::ptr::null(),
3942            image_opaque_bind_count: u32::default(),
3943            p_image_opaque_binds: ::std::ptr::null(),
3944            image_bind_count: u32::default(),
3945            p_image_binds: ::std::ptr::null(),
3946            signal_semaphore_count: u32::default(),
3947            p_signal_semaphores: ::std::ptr::null(),
3948        }
3949    }
3950}
3951impl BindSparseInfo {
3952    pub fn builder<'a>() -> BindSparseInfoBuilder<'a> {
3953        BindSparseInfoBuilder {
3954            inner: Self::default(),
3955            marker: ::std::marker::PhantomData,
3956        }
3957    }
3958}
3959#[repr(transparent)]
3960pub struct BindSparseInfoBuilder<'a> {
3961    inner: BindSparseInfo,
3962    marker: ::std::marker::PhantomData<&'a ()>,
3963}
3964pub unsafe trait ExtendsBindSparseInfo {}
3965impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> {
3966    type Target = BindSparseInfo;
3967    fn deref(&self) -> &Self::Target {
3968        &self.inner
3969    }
3970}
3971impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> {
3972    fn deref_mut(&mut self) -> &mut Self::Target {
3973        &mut self.inner
3974    }
3975}
3976impl<'a> BindSparseInfoBuilder<'a> {
3977    pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
3978        self.inner.wait_semaphore_count = wait_semaphores.len() as _;
3979        self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
3980        self
3981    }
3982    pub fn buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self {
3983        self.inner.buffer_bind_count = buffer_binds.len() as _;
3984        self.inner.p_buffer_binds = buffer_binds.as_ptr();
3985        self
3986    }
3987    pub fn image_opaque_binds(
3988        mut self,
3989        image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo],
3990    ) -> Self {
3991        self.inner.image_opaque_bind_count = image_opaque_binds.len() as _;
3992        self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr();
3993        self
3994    }
3995    pub fn image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self {
3996        self.inner.image_bind_count = image_binds.len() as _;
3997        self.inner.p_image_binds = image_binds.as_ptr();
3998        self
3999    }
4000    pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
4001        self.inner.signal_semaphore_count = signal_semaphores.len() as _;
4002        self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
4003        self
4004    }
4005    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4006    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4007    #[doc = r" valid extension structs can be pushed into the chain."]
4008    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4009    #[doc = r" chain will look like `A -> D -> B -> C`."]
4010    pub fn push_next<T: ExtendsBindSparseInfo>(mut self, next: &'a mut T) -> Self {
4011        unsafe {
4012            let next_ptr = <*const T>::cast(next);
4013            let last_next = ptr_chain_iter(next).last().unwrap();
4014            (*last_next).p_next = self.inner.p_next as _;
4015            self.inner.p_next = next_ptr;
4016        }
4017        self
4018    }
4019    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4020    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4021    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4022    pub fn build(self) -> BindSparseInfo {
4023        self.inner
4024    }
4025}
4026#[repr(C)]
4027#[cfg_attr(feature = "debug", derive(Debug))]
4028#[derive(Copy, Clone, Default)]
4029#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy.html>"]
4030pub struct ImageCopy {
4031    pub src_subresource: ImageSubresourceLayers,
4032    pub src_offset: Offset3D,
4033    pub dst_subresource: ImageSubresourceLayers,
4034    pub dst_offset: Offset3D,
4035    pub extent: Extent3D,
4036}
4037impl ImageCopy {
4038    pub fn builder<'a>() -> ImageCopyBuilder<'a> {
4039        ImageCopyBuilder {
4040            inner: Self::default(),
4041            marker: ::std::marker::PhantomData,
4042        }
4043    }
4044}
4045#[repr(transparent)]
4046pub struct ImageCopyBuilder<'a> {
4047    inner: ImageCopy,
4048    marker: ::std::marker::PhantomData<&'a ()>,
4049}
4050impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> {
4051    type Target = ImageCopy;
4052    fn deref(&self) -> &Self::Target {
4053        &self.inner
4054    }
4055}
4056impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> {
4057    fn deref_mut(&mut self) -> &mut Self::Target {
4058        &mut self.inner
4059    }
4060}
4061impl<'a> ImageCopyBuilder<'a> {
4062    pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4063        self.inner.src_subresource = src_subresource;
4064        self
4065    }
4066    pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
4067        self.inner.src_offset = src_offset;
4068        self
4069    }
4070    pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4071        self.inner.dst_subresource = dst_subresource;
4072        self
4073    }
4074    pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
4075        self.inner.dst_offset = dst_offset;
4076        self
4077    }
4078    pub fn extent(mut self, extent: Extent3D) -> Self {
4079        self.inner.extent = extent;
4080        self
4081    }
4082    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4083    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4084    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4085    pub fn build(self) -> ImageCopy {
4086        self.inner
4087    }
4088}
4089#[repr(C)]
4090#[cfg_attr(feature = "debug", derive(Debug))]
4091#[derive(Copy, Clone)]
4092#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit.html>"]
4093pub struct ImageBlit {
4094    pub src_subresource: ImageSubresourceLayers,
4095    pub src_offsets: [Offset3D; 2],
4096    pub dst_subresource: ImageSubresourceLayers,
4097    pub dst_offsets: [Offset3D; 2],
4098}
4099impl ::std::default::Default for ImageBlit {
4100    fn default() -> Self {
4101        Self {
4102            src_subresource: ImageSubresourceLayers::default(),
4103            src_offsets: unsafe { ::std::mem::zeroed() },
4104            dst_subresource: ImageSubresourceLayers::default(),
4105            dst_offsets: unsafe { ::std::mem::zeroed() },
4106        }
4107    }
4108}
4109impl ImageBlit {
4110    pub fn builder<'a>() -> ImageBlitBuilder<'a> {
4111        ImageBlitBuilder {
4112            inner: Self::default(),
4113            marker: ::std::marker::PhantomData,
4114        }
4115    }
4116}
4117#[repr(transparent)]
4118pub struct ImageBlitBuilder<'a> {
4119    inner: ImageBlit,
4120    marker: ::std::marker::PhantomData<&'a ()>,
4121}
4122impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> {
4123    type Target = ImageBlit;
4124    fn deref(&self) -> &Self::Target {
4125        &self.inner
4126    }
4127}
4128impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> {
4129    fn deref_mut(&mut self) -> &mut Self::Target {
4130        &mut self.inner
4131    }
4132}
4133impl<'a> ImageBlitBuilder<'a> {
4134    pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4135        self.inner.src_subresource = src_subresource;
4136        self
4137    }
4138    pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
4139        self.inner.src_offsets = src_offsets;
4140        self
4141    }
4142    pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4143        self.inner.dst_subresource = dst_subresource;
4144        self
4145    }
4146    pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
4147        self.inner.dst_offsets = dst_offsets;
4148        self
4149    }
4150    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4151    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4152    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4153    pub fn build(self) -> ImageBlit {
4154        self.inner
4155    }
4156}
4157#[repr(C)]
4158#[cfg_attr(feature = "debug", derive(Debug))]
4159#[derive(Copy, Clone, Default)]
4160#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy.html>"]
4161pub struct BufferImageCopy {
4162    pub buffer_offset: DeviceSize,
4163    pub buffer_row_length: u32,
4164    pub buffer_image_height: u32,
4165    pub image_subresource: ImageSubresourceLayers,
4166    pub image_offset: Offset3D,
4167    pub image_extent: Extent3D,
4168}
4169impl BufferImageCopy {
4170    pub fn builder<'a>() -> BufferImageCopyBuilder<'a> {
4171        BufferImageCopyBuilder {
4172            inner: Self::default(),
4173            marker: ::std::marker::PhantomData,
4174        }
4175    }
4176}
4177#[repr(transparent)]
4178pub struct BufferImageCopyBuilder<'a> {
4179    inner: BufferImageCopy,
4180    marker: ::std::marker::PhantomData<&'a ()>,
4181}
4182impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> {
4183    type Target = BufferImageCopy;
4184    fn deref(&self) -> &Self::Target {
4185        &self.inner
4186    }
4187}
4188impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> {
4189    fn deref_mut(&mut self) -> &mut Self::Target {
4190        &mut self.inner
4191    }
4192}
4193impl<'a> BufferImageCopyBuilder<'a> {
4194    pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
4195        self.inner.buffer_offset = buffer_offset;
4196        self
4197    }
4198    pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
4199        self.inner.buffer_row_length = buffer_row_length;
4200        self
4201    }
4202    pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
4203        self.inner.buffer_image_height = buffer_image_height;
4204        self
4205    }
4206    pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
4207        self.inner.image_subresource = image_subresource;
4208        self
4209    }
4210    pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
4211        self.inner.image_offset = image_offset;
4212        self
4213    }
4214    pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
4215        self.inner.image_extent = image_extent;
4216        self
4217    }
4218    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4219    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4220    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4221    pub fn build(self) -> BufferImageCopy {
4222        self.inner
4223    }
4224}
4225#[repr(C)]
4226#[cfg_attr(feature = "debug", derive(Debug))]
4227#[derive(Copy, Clone, Default)]
4228#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve.html>"]
4229pub struct ImageResolve {
4230    pub src_subresource: ImageSubresourceLayers,
4231    pub src_offset: Offset3D,
4232    pub dst_subresource: ImageSubresourceLayers,
4233    pub dst_offset: Offset3D,
4234    pub extent: Extent3D,
4235}
4236impl ImageResolve {
4237    pub fn builder<'a>() -> ImageResolveBuilder<'a> {
4238        ImageResolveBuilder {
4239            inner: Self::default(),
4240            marker: ::std::marker::PhantomData,
4241        }
4242    }
4243}
4244#[repr(transparent)]
4245pub struct ImageResolveBuilder<'a> {
4246    inner: ImageResolve,
4247    marker: ::std::marker::PhantomData<&'a ()>,
4248}
4249impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> {
4250    type Target = ImageResolve;
4251    fn deref(&self) -> &Self::Target {
4252        &self.inner
4253    }
4254}
4255impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> {
4256    fn deref_mut(&mut self) -> &mut Self::Target {
4257        &mut self.inner
4258    }
4259}
4260impl<'a> ImageResolveBuilder<'a> {
4261    pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
4262        self.inner.src_subresource = src_subresource;
4263        self
4264    }
4265    pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
4266        self.inner.src_offset = src_offset;
4267        self
4268    }
4269    pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
4270        self.inner.dst_subresource = dst_subresource;
4271        self
4272    }
4273    pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
4274        self.inner.dst_offset = dst_offset;
4275        self
4276    }
4277    pub fn extent(mut self, extent: Extent3D) -> Self {
4278        self.inner.extent = extent;
4279        self
4280    }
4281    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4282    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4283    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4284    pub fn build(self) -> ImageResolve {
4285        self.inner
4286    }
4287}
4288#[repr(C)]
4289#[cfg_attr(feature = "debug", derive(Debug))]
4290#[derive(Copy, Clone)]
4291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateInfo.html>"]
4292pub struct ShaderModuleCreateInfo {
4293    pub s_type: StructureType,
4294    pub p_next: *const c_void,
4295    pub flags: ShaderModuleCreateFlags,
4296    pub code_size: usize,
4297    pub p_code: *const u32,
4298}
4299impl ::std::default::Default for ShaderModuleCreateInfo {
4300    fn default() -> Self {
4301        Self {
4302            s_type: StructureType::SHADER_MODULE_CREATE_INFO,
4303            p_next: ::std::ptr::null(),
4304            flags: ShaderModuleCreateFlags::default(),
4305            code_size: usize::default(),
4306            p_code: ::std::ptr::null(),
4307        }
4308    }
4309}
4310impl ShaderModuleCreateInfo {
4311    pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> {
4312        ShaderModuleCreateInfoBuilder {
4313            inner: Self::default(),
4314            marker: ::std::marker::PhantomData,
4315        }
4316    }
4317}
4318#[repr(transparent)]
4319pub struct ShaderModuleCreateInfoBuilder<'a> {
4320    inner: ShaderModuleCreateInfo,
4321    marker: ::std::marker::PhantomData<&'a ()>,
4322}
4323pub unsafe trait ExtendsShaderModuleCreateInfo {}
4324impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
4325    type Target = ShaderModuleCreateInfo;
4326    fn deref(&self) -> &Self::Target {
4327        &self.inner
4328    }
4329}
4330impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
4331    fn deref_mut(&mut self) -> &mut Self::Target {
4332        &mut self.inner
4333    }
4334}
4335impl<'a> ShaderModuleCreateInfoBuilder<'a> {
4336    pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> Self {
4337        self.inner.flags = flags;
4338        self
4339    }
4340    pub fn code(mut self, code: &'a [u32]) -> Self {
4341        self.inner.code_size = code.len() * 4;
4342        self.inner.p_code = code.as_ptr();
4343        self
4344    }
4345    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4346    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4347    #[doc = r" valid extension structs can be pushed into the chain."]
4348    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4349    #[doc = r" chain will look like `A -> D -> B -> C`."]
4350    pub fn push_next<T: ExtendsShaderModuleCreateInfo>(mut self, next: &'a mut T) -> Self {
4351        unsafe {
4352            let next_ptr = <*const T>::cast(next);
4353            let last_next = ptr_chain_iter(next).last().unwrap();
4354            (*last_next).p_next = self.inner.p_next as _;
4355            self.inner.p_next = next_ptr;
4356        }
4357        self
4358    }
4359    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4360    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4361    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4362    pub fn build(self) -> ShaderModuleCreateInfo {
4363        self.inner
4364    }
4365}
4366#[repr(C)]
4367#[cfg_attr(feature = "debug", derive(Debug))]
4368#[derive(Copy, Clone)]
4369#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBinding.html>"]
4370pub struct DescriptorSetLayoutBinding {
4371    pub binding: u32,
4372    pub descriptor_type: DescriptorType,
4373    pub descriptor_count: u32,
4374    pub stage_flags: ShaderStageFlags,
4375    pub p_immutable_samplers: *const Sampler,
4376}
4377impl ::std::default::Default for DescriptorSetLayoutBinding {
4378    fn default() -> Self {
4379        Self {
4380            binding: u32::default(),
4381            descriptor_type: DescriptorType::default(),
4382            descriptor_count: u32::default(),
4383            stage_flags: ShaderStageFlags::default(),
4384            p_immutable_samplers: ::std::ptr::null(),
4385        }
4386    }
4387}
4388impl DescriptorSetLayoutBinding {
4389    pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> {
4390        DescriptorSetLayoutBindingBuilder {
4391            inner: Self::default(),
4392            marker: ::std::marker::PhantomData,
4393        }
4394    }
4395}
4396#[repr(transparent)]
4397pub struct DescriptorSetLayoutBindingBuilder<'a> {
4398    inner: DescriptorSetLayoutBinding,
4399    marker: ::std::marker::PhantomData<&'a ()>,
4400}
4401impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> {
4402    type Target = DescriptorSetLayoutBinding;
4403    fn deref(&self) -> &Self::Target {
4404        &self.inner
4405    }
4406}
4407impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
4408    fn deref_mut(&mut self) -> &mut Self::Target {
4409        &mut self.inner
4410    }
4411}
4412impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
4413    pub fn binding(mut self, binding: u32) -> Self {
4414        self.inner.binding = binding;
4415        self
4416    }
4417    pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
4418        self.inner.descriptor_type = descriptor_type;
4419        self
4420    }
4421    pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
4422        self.inner.descriptor_count = descriptor_count;
4423        self
4424    }
4425    pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
4426        self.inner.stage_flags = stage_flags;
4427        self
4428    }
4429    pub fn immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self {
4430        self.inner.descriptor_count = immutable_samplers.len() as _;
4431        self.inner.p_immutable_samplers = immutable_samplers.as_ptr();
4432        self
4433    }
4434    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4435    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4436    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4437    pub fn build(self) -> DescriptorSetLayoutBinding {
4438        self.inner
4439    }
4440}
4441#[repr(C)]
4442#[cfg_attr(feature = "debug", derive(Debug))]
4443#[derive(Copy, Clone)]
4444#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html>"]
4445pub struct DescriptorSetLayoutCreateInfo {
4446    pub s_type: StructureType,
4447    pub p_next: *const c_void,
4448    pub flags: DescriptorSetLayoutCreateFlags,
4449    pub binding_count: u32,
4450    pub p_bindings: *const DescriptorSetLayoutBinding,
4451}
4452impl ::std::default::Default for DescriptorSetLayoutCreateInfo {
4453    fn default() -> Self {
4454        Self {
4455            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
4456            p_next: ::std::ptr::null(),
4457            flags: DescriptorSetLayoutCreateFlags::default(),
4458            binding_count: u32::default(),
4459            p_bindings: ::std::ptr::null(),
4460        }
4461    }
4462}
4463impl DescriptorSetLayoutCreateInfo {
4464    pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
4465        DescriptorSetLayoutCreateInfoBuilder {
4466            inner: Self::default(),
4467            marker: ::std::marker::PhantomData,
4468        }
4469    }
4470}
4471#[repr(transparent)]
4472pub struct DescriptorSetLayoutCreateInfoBuilder<'a> {
4473    inner: DescriptorSetLayoutCreateInfo,
4474    marker: ::std::marker::PhantomData<&'a ()>,
4475}
4476pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {}
4477impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
4478    type Target = DescriptorSetLayoutCreateInfo;
4479    fn deref(&self) -> &Self::Target {
4480        &self.inner
4481    }
4482}
4483impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
4484    fn deref_mut(&mut self) -> &mut Self::Target {
4485        &mut self.inner
4486    }
4487}
4488impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
4489    pub fn flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self {
4490        self.inner.flags = flags;
4491        self
4492    }
4493    pub fn bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self {
4494        self.inner.binding_count = bindings.len() as _;
4495        self.inner.p_bindings = bindings.as_ptr();
4496        self
4497    }
4498    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4499    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4500    #[doc = r" valid extension structs can be pushed into the chain."]
4501    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4502    #[doc = r" chain will look like `A -> D -> B -> C`."]
4503    pub fn push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(mut self, next: &'a mut T) -> Self {
4504        unsafe {
4505            let next_ptr = <*const T>::cast(next);
4506            let last_next = ptr_chain_iter(next).last().unwrap();
4507            (*last_next).p_next = self.inner.p_next as _;
4508            self.inner.p_next = next_ptr;
4509        }
4510        self
4511    }
4512    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4513    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4514    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4515    pub fn build(self) -> DescriptorSetLayoutCreateInfo {
4516        self.inner
4517    }
4518}
4519#[repr(C)]
4520#[cfg_attr(feature = "debug", derive(Debug))]
4521#[derive(Copy, Clone, Default)]
4522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolSize.html>"]
4523pub struct DescriptorPoolSize {
4524    pub ty: DescriptorType,
4525    pub descriptor_count: u32,
4526}
4527impl DescriptorPoolSize {
4528    pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> {
4529        DescriptorPoolSizeBuilder {
4530            inner: Self::default(),
4531            marker: ::std::marker::PhantomData,
4532        }
4533    }
4534}
4535#[repr(transparent)]
4536pub struct DescriptorPoolSizeBuilder<'a> {
4537    inner: DescriptorPoolSize,
4538    marker: ::std::marker::PhantomData<&'a ()>,
4539}
4540impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> {
4541    type Target = DescriptorPoolSize;
4542    fn deref(&self) -> &Self::Target {
4543        &self.inner
4544    }
4545}
4546impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> {
4547    fn deref_mut(&mut self) -> &mut Self::Target {
4548        &mut self.inner
4549    }
4550}
4551impl<'a> DescriptorPoolSizeBuilder<'a> {
4552    pub fn ty(mut self, ty: DescriptorType) -> Self {
4553        self.inner.ty = ty;
4554        self
4555    }
4556    pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
4557        self.inner.descriptor_count = descriptor_count;
4558        self
4559    }
4560    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4561    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4562    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4563    pub fn build(self) -> DescriptorPoolSize {
4564        self.inner
4565    }
4566}
4567#[repr(C)]
4568#[cfg_attr(feature = "debug", derive(Debug))]
4569#[derive(Copy, Clone)]
4570#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateInfo.html>"]
4571pub struct DescriptorPoolCreateInfo {
4572    pub s_type: StructureType,
4573    pub p_next: *const c_void,
4574    pub flags: DescriptorPoolCreateFlags,
4575    pub max_sets: u32,
4576    pub pool_size_count: u32,
4577    pub p_pool_sizes: *const DescriptorPoolSize,
4578}
4579impl ::std::default::Default for DescriptorPoolCreateInfo {
4580    fn default() -> Self {
4581        Self {
4582            s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO,
4583            p_next: ::std::ptr::null(),
4584            flags: DescriptorPoolCreateFlags::default(),
4585            max_sets: u32::default(),
4586            pool_size_count: u32::default(),
4587            p_pool_sizes: ::std::ptr::null(),
4588        }
4589    }
4590}
4591impl DescriptorPoolCreateInfo {
4592    pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> {
4593        DescriptorPoolCreateInfoBuilder {
4594            inner: Self::default(),
4595            marker: ::std::marker::PhantomData,
4596        }
4597    }
4598}
4599#[repr(transparent)]
4600pub struct DescriptorPoolCreateInfoBuilder<'a> {
4601    inner: DescriptorPoolCreateInfo,
4602    marker: ::std::marker::PhantomData<&'a ()>,
4603}
4604pub unsafe trait ExtendsDescriptorPoolCreateInfo {}
4605impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> {
4606    type Target = DescriptorPoolCreateInfo;
4607    fn deref(&self) -> &Self::Target {
4608        &self.inner
4609    }
4610}
4611impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
4612    fn deref_mut(&mut self) -> &mut Self::Target {
4613        &mut self.inner
4614    }
4615}
4616impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
4617    pub fn flags(mut self, flags: DescriptorPoolCreateFlags) -> Self {
4618        self.inner.flags = flags;
4619        self
4620    }
4621    pub fn max_sets(mut self, max_sets: u32) -> Self {
4622        self.inner.max_sets = max_sets;
4623        self
4624    }
4625    pub fn pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self {
4626        self.inner.pool_size_count = pool_sizes.len() as _;
4627        self.inner.p_pool_sizes = pool_sizes.as_ptr();
4628        self
4629    }
4630    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4631    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4632    #[doc = r" valid extension structs can be pushed into the chain."]
4633    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4634    #[doc = r" chain will look like `A -> D -> B -> C`."]
4635    pub fn push_next<T: ExtendsDescriptorPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
4636        unsafe {
4637            let next_ptr = <*const T>::cast(next);
4638            let last_next = ptr_chain_iter(next).last().unwrap();
4639            (*last_next).p_next = self.inner.p_next as _;
4640            self.inner.p_next = next_ptr;
4641        }
4642        self
4643    }
4644    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4645    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4646    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4647    pub fn build(self) -> DescriptorPoolCreateInfo {
4648        self.inner
4649    }
4650}
4651#[repr(C)]
4652#[cfg_attr(feature = "debug", derive(Debug))]
4653#[derive(Copy, Clone)]
4654#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetAllocateInfo.html>"]
4655pub struct DescriptorSetAllocateInfo {
4656    pub s_type: StructureType,
4657    pub p_next: *const c_void,
4658    pub descriptor_pool: DescriptorPool,
4659    pub descriptor_set_count: u32,
4660    pub p_set_layouts: *const DescriptorSetLayout,
4661}
4662impl ::std::default::Default for DescriptorSetAllocateInfo {
4663    fn default() -> Self {
4664        Self {
4665            s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO,
4666            p_next: ::std::ptr::null(),
4667            descriptor_pool: DescriptorPool::default(),
4668            descriptor_set_count: u32::default(),
4669            p_set_layouts: ::std::ptr::null(),
4670        }
4671    }
4672}
4673impl DescriptorSetAllocateInfo {
4674    pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> {
4675        DescriptorSetAllocateInfoBuilder {
4676            inner: Self::default(),
4677            marker: ::std::marker::PhantomData,
4678        }
4679    }
4680}
4681#[repr(transparent)]
4682pub struct DescriptorSetAllocateInfoBuilder<'a> {
4683    inner: DescriptorSetAllocateInfo,
4684    marker: ::std::marker::PhantomData<&'a ()>,
4685}
4686pub unsafe trait ExtendsDescriptorSetAllocateInfo {}
4687impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> {
4688    type Target = DescriptorSetAllocateInfo;
4689    fn deref(&self) -> &Self::Target {
4690        &self.inner
4691    }
4692}
4693impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
4694    fn deref_mut(&mut self) -> &mut Self::Target {
4695        &mut self.inner
4696    }
4697}
4698impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
4699    pub fn descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self {
4700        self.inner.descriptor_pool = descriptor_pool;
4701        self
4702    }
4703    pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
4704        self.inner.descriptor_set_count = set_layouts.len() as _;
4705        self.inner.p_set_layouts = set_layouts.as_ptr();
4706        self
4707    }
4708    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4709    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4710    #[doc = r" valid extension structs can be pushed into the chain."]
4711    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4712    #[doc = r" chain will look like `A -> D -> B -> C`."]
4713    pub fn push_next<T: ExtendsDescriptorSetAllocateInfo>(mut self, next: &'a mut T) -> Self {
4714        unsafe {
4715            let next_ptr = <*const T>::cast(next);
4716            let last_next = ptr_chain_iter(next).last().unwrap();
4717            (*last_next).p_next = self.inner.p_next as _;
4718            self.inner.p_next = next_ptr;
4719        }
4720        self
4721    }
4722    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4723    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4724    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4725    pub fn build(self) -> DescriptorSetAllocateInfo {
4726        self.inner
4727    }
4728}
4729#[repr(C)]
4730#[cfg_attr(feature = "debug", derive(Debug))]
4731#[derive(Copy, Clone, Default)]
4732#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationMapEntry.html>"]
4733pub struct SpecializationMapEntry {
4734    pub constant_id: u32,
4735    pub offset: u32,
4736    pub size: usize,
4737}
4738impl SpecializationMapEntry {
4739    pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> {
4740        SpecializationMapEntryBuilder {
4741            inner: Self::default(),
4742            marker: ::std::marker::PhantomData,
4743        }
4744    }
4745}
4746#[repr(transparent)]
4747pub struct SpecializationMapEntryBuilder<'a> {
4748    inner: SpecializationMapEntry,
4749    marker: ::std::marker::PhantomData<&'a ()>,
4750}
4751impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> {
4752    type Target = SpecializationMapEntry;
4753    fn deref(&self) -> &Self::Target {
4754        &self.inner
4755    }
4756}
4757impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> {
4758    fn deref_mut(&mut self) -> &mut Self::Target {
4759        &mut self.inner
4760    }
4761}
4762impl<'a> SpecializationMapEntryBuilder<'a> {
4763    pub fn constant_id(mut self, constant_id: u32) -> Self {
4764        self.inner.constant_id = constant_id;
4765        self
4766    }
4767    pub fn offset(mut self, offset: u32) -> Self {
4768        self.inner.offset = offset;
4769        self
4770    }
4771    pub fn size(mut self, size: usize) -> Self {
4772        self.inner.size = size;
4773        self
4774    }
4775    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4776    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4777    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4778    pub fn build(self) -> SpecializationMapEntry {
4779        self.inner
4780    }
4781}
4782#[repr(C)]
4783#[cfg_attr(feature = "debug", derive(Debug))]
4784#[derive(Copy, Clone)]
4785#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationInfo.html>"]
4786pub struct SpecializationInfo {
4787    pub map_entry_count: u32,
4788    pub p_map_entries: *const SpecializationMapEntry,
4789    pub data_size: usize,
4790    pub p_data: *const c_void,
4791}
4792impl ::std::default::Default for SpecializationInfo {
4793    fn default() -> Self {
4794        Self {
4795            map_entry_count: u32::default(),
4796            p_map_entries: ::std::ptr::null(),
4797            data_size: usize::default(),
4798            p_data: ::std::ptr::null(),
4799        }
4800    }
4801}
4802impl SpecializationInfo {
4803    pub fn builder<'a>() -> SpecializationInfoBuilder<'a> {
4804        SpecializationInfoBuilder {
4805            inner: Self::default(),
4806            marker: ::std::marker::PhantomData,
4807        }
4808    }
4809}
4810#[repr(transparent)]
4811pub struct SpecializationInfoBuilder<'a> {
4812    inner: SpecializationInfo,
4813    marker: ::std::marker::PhantomData<&'a ()>,
4814}
4815impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> {
4816    type Target = SpecializationInfo;
4817    fn deref(&self) -> &Self::Target {
4818        &self.inner
4819    }
4820}
4821impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> {
4822    fn deref_mut(&mut self) -> &mut Self::Target {
4823        &mut self.inner
4824    }
4825}
4826impl<'a> SpecializationInfoBuilder<'a> {
4827    pub fn map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self {
4828        self.inner.map_entry_count = map_entries.len() as _;
4829        self.inner.p_map_entries = map_entries.as_ptr();
4830        self
4831    }
4832    pub fn data(mut self, data: &'a [u8]) -> Self {
4833        self.inner.data_size = data.len();
4834        self.inner.p_data = data.as_ptr() as *const c_void;
4835        self
4836    }
4837    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4838    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4839    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4840    pub fn build(self) -> SpecializationInfo {
4841        self.inner
4842    }
4843}
4844#[repr(C)]
4845#[cfg_attr(feature = "debug", derive(Debug))]
4846#[derive(Copy, Clone)]
4847#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateInfo.html>"]
4848pub struct PipelineShaderStageCreateInfo {
4849    pub s_type: StructureType,
4850    pub p_next: *const c_void,
4851    pub flags: PipelineShaderStageCreateFlags,
4852    pub stage: ShaderStageFlags,
4853    pub module: ShaderModule,
4854    pub p_name: *const c_char,
4855    pub p_specialization_info: *const SpecializationInfo,
4856}
4857impl ::std::default::Default for PipelineShaderStageCreateInfo {
4858    fn default() -> Self {
4859        Self {
4860            s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
4861            p_next: ::std::ptr::null(),
4862            flags: PipelineShaderStageCreateFlags::default(),
4863            stage: ShaderStageFlags::default(),
4864            module: ShaderModule::default(),
4865            p_name: ::std::ptr::null(),
4866            p_specialization_info: ::std::ptr::null(),
4867        }
4868    }
4869}
4870impl PipelineShaderStageCreateInfo {
4871    pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> {
4872        PipelineShaderStageCreateInfoBuilder {
4873            inner: Self::default(),
4874            marker: ::std::marker::PhantomData,
4875        }
4876    }
4877}
4878#[repr(transparent)]
4879pub struct PipelineShaderStageCreateInfoBuilder<'a> {
4880    inner: PipelineShaderStageCreateInfo,
4881    marker: ::std::marker::PhantomData<&'a ()>,
4882}
4883pub unsafe trait ExtendsPipelineShaderStageCreateInfo {}
4884impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> {
4885    type Target = PipelineShaderStageCreateInfo;
4886    fn deref(&self) -> &Self::Target {
4887        &self.inner
4888    }
4889}
4890impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
4891    fn deref_mut(&mut self) -> &mut Self::Target {
4892        &mut self.inner
4893    }
4894}
4895impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
4896    pub fn flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self {
4897        self.inner.flags = flags;
4898        self
4899    }
4900    pub fn stage(mut self, stage: ShaderStageFlags) -> Self {
4901        self.inner.stage = stage;
4902        self
4903    }
4904    pub fn module(mut self, module: ShaderModule) -> Self {
4905        self.inner.module = module;
4906        self
4907    }
4908    pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
4909        self.inner.p_name = name.as_ptr();
4910        self
4911    }
4912    pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self {
4913        self.inner.p_specialization_info = specialization_info;
4914        self
4915    }
4916    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4917    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4918    #[doc = r" valid extension structs can be pushed into the chain."]
4919    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4920    #[doc = r" chain will look like `A -> D -> B -> C`."]
4921    pub fn push_next<T: ExtendsPipelineShaderStageCreateInfo>(mut self, next: &'a mut T) -> Self {
4922        unsafe {
4923            let next_ptr = <*const T>::cast(next);
4924            let last_next = ptr_chain_iter(next).last().unwrap();
4925            (*last_next).p_next = self.inner.p_next as _;
4926            self.inner.p_next = next_ptr;
4927        }
4928        self
4929    }
4930    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4931    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4932    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
4933    pub fn build(self) -> PipelineShaderStageCreateInfo {
4934        self.inner
4935    }
4936}
4937#[repr(C)]
4938#[cfg_attr(feature = "debug", derive(Debug))]
4939#[derive(Copy, Clone)]
4940#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComputePipelineCreateInfo.html>"]
4941pub struct ComputePipelineCreateInfo {
4942    pub s_type: StructureType,
4943    pub p_next: *const c_void,
4944    pub flags: PipelineCreateFlags,
4945    pub stage: PipelineShaderStageCreateInfo,
4946    pub layout: PipelineLayout,
4947    pub base_pipeline_handle: Pipeline,
4948    pub base_pipeline_index: i32,
4949}
4950impl ::std::default::Default for ComputePipelineCreateInfo {
4951    fn default() -> Self {
4952        Self {
4953            s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO,
4954            p_next: ::std::ptr::null(),
4955            flags: PipelineCreateFlags::default(),
4956            stage: PipelineShaderStageCreateInfo::default(),
4957            layout: PipelineLayout::default(),
4958            base_pipeline_handle: Pipeline::default(),
4959            base_pipeline_index: i32::default(),
4960        }
4961    }
4962}
4963impl ComputePipelineCreateInfo {
4964    pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> {
4965        ComputePipelineCreateInfoBuilder {
4966            inner: Self::default(),
4967            marker: ::std::marker::PhantomData,
4968        }
4969    }
4970}
4971#[repr(transparent)]
4972pub struct ComputePipelineCreateInfoBuilder<'a> {
4973    inner: ComputePipelineCreateInfo,
4974    marker: ::std::marker::PhantomData<&'a ()>,
4975}
4976pub unsafe trait ExtendsComputePipelineCreateInfo {}
4977impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> {
4978    type Target = ComputePipelineCreateInfo;
4979    fn deref(&self) -> &Self::Target {
4980        &self.inner
4981    }
4982}
4983impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
4984    fn deref_mut(&mut self) -> &mut Self::Target {
4985        &mut self.inner
4986    }
4987}
4988impl<'a> ComputePipelineCreateInfoBuilder<'a> {
4989    pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
4990        self.inner.flags = flags;
4991        self
4992    }
4993    pub fn stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self {
4994        self.inner.stage = stage;
4995        self
4996    }
4997    pub fn layout(mut self, layout: PipelineLayout) -> Self {
4998        self.inner.layout = layout;
4999        self
5000    }
5001    pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
5002        self.inner.base_pipeline_handle = base_pipeline_handle;
5003        self
5004    }
5005    pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
5006        self.inner.base_pipeline_index = base_pipeline_index;
5007        self
5008    }
5009    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5010    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5011    #[doc = r" valid extension structs can be pushed into the chain."]
5012    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5013    #[doc = r" chain will look like `A -> D -> B -> C`."]
5014    pub fn push_next<T: ExtendsComputePipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
5015        unsafe {
5016            let next_ptr = <*const T>::cast(next);
5017            let last_next = ptr_chain_iter(next).last().unwrap();
5018            (*last_next).p_next = self.inner.p_next as _;
5019            self.inner.p_next = next_ptr;
5020        }
5021        self
5022    }
5023    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5024    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5025    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5026    pub fn build(self) -> ComputePipelineCreateInfo {
5027        self.inner
5028    }
5029}
5030#[repr(C)]
5031#[cfg_attr(feature = "debug", derive(Debug))]
5032#[derive(Copy, Clone, Default)]
5033#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription.html>"]
5034pub struct VertexInputBindingDescription {
5035    pub binding: u32,
5036    pub stride: u32,
5037    pub input_rate: VertexInputRate,
5038}
5039impl VertexInputBindingDescription {
5040    pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> {
5041        VertexInputBindingDescriptionBuilder {
5042            inner: Self::default(),
5043            marker: ::std::marker::PhantomData,
5044        }
5045    }
5046}
5047#[repr(transparent)]
5048pub struct VertexInputBindingDescriptionBuilder<'a> {
5049    inner: VertexInputBindingDescription,
5050    marker: ::std::marker::PhantomData<&'a ()>,
5051}
5052impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> {
5053    type Target = VertexInputBindingDescription;
5054    fn deref(&self) -> &Self::Target {
5055        &self.inner
5056    }
5057}
5058impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> {
5059    fn deref_mut(&mut self) -> &mut Self::Target {
5060        &mut self.inner
5061    }
5062}
5063impl<'a> VertexInputBindingDescriptionBuilder<'a> {
5064    pub fn binding(mut self, binding: u32) -> Self {
5065        self.inner.binding = binding;
5066        self
5067    }
5068    pub fn stride(mut self, stride: u32) -> Self {
5069        self.inner.stride = stride;
5070        self
5071    }
5072    pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
5073        self.inner.input_rate = input_rate;
5074        self
5075    }
5076    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5077    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5078    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5079    pub fn build(self) -> VertexInputBindingDescription {
5080        self.inner
5081    }
5082}
5083#[repr(C)]
5084#[cfg_attr(feature = "debug", derive(Debug))]
5085#[derive(Copy, Clone, Default)]
5086#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription.html>"]
5087pub struct VertexInputAttributeDescription {
5088    pub location: u32,
5089    pub binding: u32,
5090    pub format: Format,
5091    pub offset: u32,
5092}
5093impl VertexInputAttributeDescription {
5094    pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> {
5095        VertexInputAttributeDescriptionBuilder {
5096            inner: Self::default(),
5097            marker: ::std::marker::PhantomData,
5098        }
5099    }
5100}
5101#[repr(transparent)]
5102pub struct VertexInputAttributeDescriptionBuilder<'a> {
5103    inner: VertexInputAttributeDescription,
5104    marker: ::std::marker::PhantomData<&'a ()>,
5105}
5106impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> {
5107    type Target = VertexInputAttributeDescription;
5108    fn deref(&self) -> &Self::Target {
5109        &self.inner
5110    }
5111}
5112impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> {
5113    fn deref_mut(&mut self) -> &mut Self::Target {
5114        &mut self.inner
5115    }
5116}
5117impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
5118    pub fn location(mut self, location: u32) -> Self {
5119        self.inner.location = location;
5120        self
5121    }
5122    pub fn binding(mut self, binding: u32) -> Self {
5123        self.inner.binding = binding;
5124        self
5125    }
5126    pub fn format(mut self, format: Format) -> Self {
5127        self.inner.format = format;
5128        self
5129    }
5130    pub fn offset(mut self, offset: u32) -> Self {
5131        self.inner.offset = offset;
5132        self
5133    }
5134    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5135    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5136    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5137    pub fn build(self) -> VertexInputAttributeDescription {
5138        self.inner
5139    }
5140}
5141#[repr(C)]
5142#[cfg_attr(feature = "debug", derive(Debug))]
5143#[derive(Copy, Clone)]
5144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html>"]
5145pub struct PipelineVertexInputStateCreateInfo {
5146    pub s_type: StructureType,
5147    pub p_next: *const c_void,
5148    pub flags: PipelineVertexInputStateCreateFlags,
5149    pub vertex_binding_description_count: u32,
5150    pub p_vertex_binding_descriptions: *const VertexInputBindingDescription,
5151    pub vertex_attribute_description_count: u32,
5152    pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription,
5153}
5154impl ::std::default::Default for PipelineVertexInputStateCreateInfo {
5155    fn default() -> Self {
5156        Self {
5157            s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
5158            p_next: ::std::ptr::null(),
5159            flags: PipelineVertexInputStateCreateFlags::default(),
5160            vertex_binding_description_count: u32::default(),
5161            p_vertex_binding_descriptions: ::std::ptr::null(),
5162            vertex_attribute_description_count: u32::default(),
5163            p_vertex_attribute_descriptions: ::std::ptr::null(),
5164        }
5165    }
5166}
5167impl PipelineVertexInputStateCreateInfo {
5168    pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5169        PipelineVertexInputStateCreateInfoBuilder {
5170            inner: Self::default(),
5171            marker: ::std::marker::PhantomData,
5172        }
5173    }
5174}
5175#[repr(transparent)]
5176pub struct PipelineVertexInputStateCreateInfoBuilder<'a> {
5177    inner: PipelineVertexInputStateCreateInfo,
5178    marker: ::std::marker::PhantomData<&'a ()>,
5179}
5180pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {}
5181impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
5182    type Target = PipelineVertexInputStateCreateInfo;
5183    fn deref(&self) -> &Self::Target {
5184        &self.inner
5185    }
5186}
5187impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> {
5188    fn deref_mut(&mut self) -> &mut Self::Target {
5189        &mut self.inner
5190    }
5191}
5192impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
5193    pub fn flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self {
5194        self.inner.flags = flags;
5195        self
5196    }
5197    pub fn vertex_binding_descriptions(
5198        mut self,
5199        vertex_binding_descriptions: &'a [VertexInputBindingDescription],
5200    ) -> Self {
5201        self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _;
5202        self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr();
5203        self
5204    }
5205    pub fn vertex_attribute_descriptions(
5206        mut self,
5207        vertex_attribute_descriptions: &'a [VertexInputAttributeDescription],
5208    ) -> Self {
5209        self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _;
5210        self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr();
5211        self
5212    }
5213    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5214    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5215    #[doc = r" valid extension structs can be pushed into the chain."]
5216    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5217    #[doc = r" chain will look like `A -> D -> B -> C`."]
5218    pub fn push_next<T: ExtendsPipelineVertexInputStateCreateInfo>(
5219        mut self,
5220        next: &'a mut T,
5221    ) -> Self {
5222        unsafe {
5223            let next_ptr = <*const T>::cast(next);
5224            let last_next = ptr_chain_iter(next).last().unwrap();
5225            (*last_next).p_next = self.inner.p_next as _;
5226            self.inner.p_next = next_ptr;
5227        }
5228        self
5229    }
5230    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5231    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5232    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5233    pub fn build(self) -> PipelineVertexInputStateCreateInfo {
5234        self.inner
5235    }
5236}
5237#[repr(C)]
5238#[cfg_attr(feature = "debug", derive(Debug))]
5239#[derive(Copy, Clone)]
5240#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html>"]
5241pub struct PipelineInputAssemblyStateCreateInfo {
5242    pub s_type: StructureType,
5243    pub p_next: *const c_void,
5244    pub flags: PipelineInputAssemblyStateCreateFlags,
5245    pub topology: PrimitiveTopology,
5246    pub primitive_restart_enable: Bool32,
5247}
5248impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo {
5249    fn default() -> Self {
5250        Self {
5251            s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
5252            p_next: ::std::ptr::null(),
5253            flags: PipelineInputAssemblyStateCreateFlags::default(),
5254            topology: PrimitiveTopology::default(),
5255            primitive_restart_enable: Bool32::default(),
5256        }
5257    }
5258}
5259impl PipelineInputAssemblyStateCreateInfo {
5260    pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5261        PipelineInputAssemblyStateCreateInfoBuilder {
5262            inner: Self::default(),
5263            marker: ::std::marker::PhantomData,
5264        }
5265    }
5266}
5267#[repr(transparent)]
5268pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5269    inner: PipelineInputAssemblyStateCreateInfo,
5270    marker: ::std::marker::PhantomData<&'a ()>,
5271}
5272impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5273    type Target = PipelineInputAssemblyStateCreateInfo;
5274    fn deref(&self) -> &Self::Target {
5275        &self.inner
5276    }
5277}
5278impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5279    fn deref_mut(&mut self) -> &mut Self::Target {
5280        &mut self.inner
5281    }
5282}
5283impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5284    pub fn flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self {
5285        self.inner.flags = flags;
5286        self
5287    }
5288    pub fn topology(mut self, topology: PrimitiveTopology) -> Self {
5289        self.inner.topology = topology;
5290        self
5291    }
5292    pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self {
5293        self.inner.primitive_restart_enable = primitive_restart_enable.into();
5294        self
5295    }
5296    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5297    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5298    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5299    pub fn build(self) -> PipelineInputAssemblyStateCreateInfo {
5300        self.inner
5301    }
5302}
5303#[repr(C)]
5304#[cfg_attr(feature = "debug", derive(Debug))]
5305#[derive(Copy, Clone)]
5306#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateInfo.html>"]
5307pub struct PipelineTessellationStateCreateInfo {
5308    pub s_type: StructureType,
5309    pub p_next: *const c_void,
5310    pub flags: PipelineTessellationStateCreateFlags,
5311    pub patch_control_points: u32,
5312}
5313impl ::std::default::Default for PipelineTessellationStateCreateInfo {
5314    fn default() -> Self {
5315        Self {
5316            s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO,
5317            p_next: ::std::ptr::null(),
5318            flags: PipelineTessellationStateCreateFlags::default(),
5319            patch_control_points: u32::default(),
5320        }
5321    }
5322}
5323impl PipelineTessellationStateCreateInfo {
5324    pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> {
5325        PipelineTessellationStateCreateInfoBuilder {
5326            inner: Self::default(),
5327            marker: ::std::marker::PhantomData,
5328        }
5329    }
5330}
5331#[repr(transparent)]
5332pub struct PipelineTessellationStateCreateInfoBuilder<'a> {
5333    inner: PipelineTessellationStateCreateInfo,
5334    marker: ::std::marker::PhantomData<&'a ()>,
5335}
5336pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {}
5337impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
5338    type Target = PipelineTessellationStateCreateInfo;
5339    fn deref(&self) -> &Self::Target {
5340        &self.inner
5341    }
5342}
5343impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> {
5344    fn deref_mut(&mut self) -> &mut Self::Target {
5345        &mut self.inner
5346    }
5347}
5348impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
5349    pub fn flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self {
5350        self.inner.flags = flags;
5351        self
5352    }
5353    pub fn patch_control_points(mut self, patch_control_points: u32) -> Self {
5354        self.inner.patch_control_points = patch_control_points;
5355        self
5356    }
5357    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5358    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5359    #[doc = r" valid extension structs can be pushed into the chain."]
5360    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5361    #[doc = r" chain will look like `A -> D -> B -> C`."]
5362    pub fn push_next<T: ExtendsPipelineTessellationStateCreateInfo>(
5363        mut self,
5364        next: &'a mut T,
5365    ) -> Self {
5366        unsafe {
5367            let next_ptr = <*const T>::cast(next);
5368            let last_next = ptr_chain_iter(next).last().unwrap();
5369            (*last_next).p_next = self.inner.p_next as _;
5370            self.inner.p_next = next_ptr;
5371        }
5372        self
5373    }
5374    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5375    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5376    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5377    pub fn build(self) -> PipelineTessellationStateCreateInfo {
5378        self.inner
5379    }
5380}
5381#[repr(C)]
5382#[cfg_attr(feature = "debug", derive(Debug))]
5383#[derive(Copy, Clone)]
5384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateInfo.html>"]
5385pub struct PipelineViewportStateCreateInfo {
5386    pub s_type: StructureType,
5387    pub p_next: *const c_void,
5388    pub flags: PipelineViewportStateCreateFlags,
5389    pub viewport_count: u32,
5390    pub p_viewports: *const Viewport,
5391    pub scissor_count: u32,
5392    pub p_scissors: *const Rect2D,
5393}
5394impl ::std::default::Default for PipelineViewportStateCreateInfo {
5395    fn default() -> Self {
5396        Self {
5397            s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO,
5398            p_next: ::std::ptr::null(),
5399            flags: PipelineViewportStateCreateFlags::default(),
5400            viewport_count: u32::default(),
5401            p_viewports: ::std::ptr::null(),
5402            scissor_count: u32::default(),
5403            p_scissors: ::std::ptr::null(),
5404        }
5405    }
5406}
5407impl PipelineViewportStateCreateInfo {
5408    pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> {
5409        PipelineViewportStateCreateInfoBuilder {
5410            inner: Self::default(),
5411            marker: ::std::marker::PhantomData,
5412        }
5413    }
5414}
5415#[repr(transparent)]
5416pub struct PipelineViewportStateCreateInfoBuilder<'a> {
5417    inner: PipelineViewportStateCreateInfo,
5418    marker: ::std::marker::PhantomData<&'a ()>,
5419}
5420pub unsafe trait ExtendsPipelineViewportStateCreateInfo {}
5421impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> {
5422    type Target = PipelineViewportStateCreateInfo;
5423    fn deref(&self) -> &Self::Target {
5424        &self.inner
5425    }
5426}
5427impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
5428    fn deref_mut(&mut self) -> &mut Self::Target {
5429        &mut self.inner
5430    }
5431}
5432impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
5433    pub fn flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self {
5434        self.inner.flags = flags;
5435        self
5436    }
5437    pub fn viewport_count(mut self, viewport_count: u32) -> Self {
5438        self.inner.viewport_count = viewport_count;
5439        self
5440    }
5441    pub fn viewports(mut self, viewports: &'a [Viewport]) -> Self {
5442        self.inner.viewport_count = viewports.len() as _;
5443        self.inner.p_viewports = viewports.as_ptr();
5444        self
5445    }
5446    pub fn scissor_count(mut self, scissor_count: u32) -> Self {
5447        self.inner.scissor_count = scissor_count;
5448        self
5449    }
5450    pub fn scissors(mut self, scissors: &'a [Rect2D]) -> Self {
5451        self.inner.scissor_count = scissors.len() as _;
5452        self.inner.p_scissors = scissors.as_ptr();
5453        self
5454    }
5455    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5456    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5457    #[doc = r" valid extension structs can be pushed into the chain."]
5458    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5459    #[doc = r" chain will look like `A -> D -> B -> C`."]
5460    pub fn push_next<T: ExtendsPipelineViewportStateCreateInfo>(mut self, next: &'a mut T) -> Self {
5461        unsafe {
5462            let next_ptr = <*const T>::cast(next);
5463            let last_next = ptr_chain_iter(next).last().unwrap();
5464            (*last_next).p_next = self.inner.p_next as _;
5465            self.inner.p_next = next_ptr;
5466        }
5467        self
5468    }
5469    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5470    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5471    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5472    pub fn build(self) -> PipelineViewportStateCreateInfo {
5473        self.inner
5474    }
5475}
5476#[repr(C)]
5477#[cfg_attr(feature = "debug", derive(Debug))]
5478#[derive(Copy, Clone)]
5479#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html>"]
5480pub struct PipelineRasterizationStateCreateInfo {
5481    pub s_type: StructureType,
5482    pub p_next: *const c_void,
5483    pub flags: PipelineRasterizationStateCreateFlags,
5484    pub depth_clamp_enable: Bool32,
5485    pub rasterizer_discard_enable: Bool32,
5486    pub polygon_mode: PolygonMode,
5487    pub cull_mode: CullModeFlags,
5488    pub front_face: FrontFace,
5489    pub depth_bias_enable: Bool32,
5490    pub depth_bias_constant_factor: f32,
5491    pub depth_bias_clamp: f32,
5492    pub depth_bias_slope_factor: f32,
5493    pub line_width: f32,
5494}
5495impl ::std::default::Default for PipelineRasterizationStateCreateInfo {
5496    fn default() -> Self {
5497        Self {
5498            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
5499            p_next: ::std::ptr::null(),
5500            flags: PipelineRasterizationStateCreateFlags::default(),
5501            depth_clamp_enable: Bool32::default(),
5502            rasterizer_discard_enable: Bool32::default(),
5503            polygon_mode: PolygonMode::default(),
5504            cull_mode: CullModeFlags::default(),
5505            front_face: FrontFace::default(),
5506            depth_bias_enable: Bool32::default(),
5507            depth_bias_constant_factor: f32::default(),
5508            depth_bias_clamp: f32::default(),
5509            depth_bias_slope_factor: f32::default(),
5510            line_width: f32::default(),
5511        }
5512    }
5513}
5514impl PipelineRasterizationStateCreateInfo {
5515    pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5516        PipelineRasterizationStateCreateInfoBuilder {
5517            inner: Self::default(),
5518            marker: ::std::marker::PhantomData,
5519        }
5520    }
5521}
5522#[repr(transparent)]
5523pub struct PipelineRasterizationStateCreateInfoBuilder<'a> {
5524    inner: PipelineRasterizationStateCreateInfo,
5525    marker: ::std::marker::PhantomData<&'a ()>,
5526}
5527pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {}
5528impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
5529    type Target = PipelineRasterizationStateCreateInfo;
5530    fn deref(&self) -> &Self::Target {
5531        &self.inner
5532    }
5533}
5534impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> {
5535    fn deref_mut(&mut self) -> &mut Self::Target {
5536        &mut self.inner
5537    }
5538}
5539impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
5540    pub fn flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self {
5541        self.inner.flags = flags;
5542        self
5543    }
5544    pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self {
5545        self.inner.depth_clamp_enable = depth_clamp_enable.into();
5546        self
5547    }
5548    pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self {
5549        self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into();
5550        self
5551    }
5552    pub fn polygon_mode(mut self, polygon_mode: PolygonMode) -> Self {
5553        self.inner.polygon_mode = polygon_mode;
5554        self
5555    }
5556    pub fn cull_mode(mut self, cull_mode: CullModeFlags) -> Self {
5557        self.inner.cull_mode = cull_mode;
5558        self
5559    }
5560    pub fn front_face(mut self, front_face: FrontFace) -> Self {
5561        self.inner.front_face = front_face;
5562        self
5563    }
5564    pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self {
5565        self.inner.depth_bias_enable = depth_bias_enable.into();
5566        self
5567    }
5568    pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self {
5569        self.inner.depth_bias_constant_factor = depth_bias_constant_factor;
5570        self
5571    }
5572    pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self {
5573        self.inner.depth_bias_clamp = depth_bias_clamp;
5574        self
5575    }
5576    pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self {
5577        self.inner.depth_bias_slope_factor = depth_bias_slope_factor;
5578        self
5579    }
5580    pub fn line_width(mut self, line_width: f32) -> Self {
5581        self.inner.line_width = line_width;
5582        self
5583    }
5584    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5585    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5586    #[doc = r" valid extension structs can be pushed into the chain."]
5587    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5588    #[doc = r" chain will look like `A -> D -> B -> C`."]
5589    pub fn push_next<T: ExtendsPipelineRasterizationStateCreateInfo>(
5590        mut self,
5591        next: &'a mut T,
5592    ) -> Self {
5593        unsafe {
5594            let next_ptr = <*const T>::cast(next);
5595            let last_next = ptr_chain_iter(next).last().unwrap();
5596            (*last_next).p_next = self.inner.p_next as _;
5597            self.inner.p_next = next_ptr;
5598        }
5599        self
5600    }
5601    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5602    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5603    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5604    pub fn build(self) -> PipelineRasterizationStateCreateInfo {
5605        self.inner
5606    }
5607}
5608#[repr(C)]
5609#[cfg_attr(feature = "debug", derive(Debug))]
5610#[derive(Copy, Clone)]
5611#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html>"]
5612pub struct PipelineMultisampleStateCreateInfo {
5613    pub s_type: StructureType,
5614    pub p_next: *const c_void,
5615    pub flags: PipelineMultisampleStateCreateFlags,
5616    pub rasterization_samples: SampleCountFlags,
5617    pub sample_shading_enable: Bool32,
5618    pub min_sample_shading: f32,
5619    pub p_sample_mask: *const SampleMask,
5620    pub alpha_to_coverage_enable: Bool32,
5621    pub alpha_to_one_enable: Bool32,
5622}
5623impl ::std::default::Default for PipelineMultisampleStateCreateInfo {
5624    fn default() -> Self {
5625        Self {
5626            s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
5627            p_next: ::std::ptr::null(),
5628            flags: PipelineMultisampleStateCreateFlags::default(),
5629            rasterization_samples: SampleCountFlags::default(),
5630            sample_shading_enable: Bool32::default(),
5631            min_sample_shading: f32::default(),
5632            p_sample_mask: ::std::ptr::null(),
5633            alpha_to_coverage_enable: Bool32::default(),
5634            alpha_to_one_enable: Bool32::default(),
5635        }
5636    }
5637}
5638impl PipelineMultisampleStateCreateInfo {
5639    pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
5640        PipelineMultisampleStateCreateInfoBuilder {
5641            inner: Self::default(),
5642            marker: ::std::marker::PhantomData,
5643        }
5644    }
5645}
5646#[repr(transparent)]
5647pub struct PipelineMultisampleStateCreateInfoBuilder<'a> {
5648    inner: PipelineMultisampleStateCreateInfo,
5649    marker: ::std::marker::PhantomData<&'a ()>,
5650}
5651pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {}
5652impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
5653    type Target = PipelineMultisampleStateCreateInfo;
5654    fn deref(&self) -> &Self::Target {
5655        &self.inner
5656    }
5657}
5658impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> {
5659    fn deref_mut(&mut self) -> &mut Self::Target {
5660        &mut self.inner
5661    }
5662}
5663impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
5664    pub fn flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self {
5665        self.inner.flags = flags;
5666        self
5667    }
5668    pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
5669        self.inner.rasterization_samples = rasterization_samples;
5670        self
5671    }
5672    pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self {
5673        self.inner.sample_shading_enable = sample_shading_enable.into();
5674        self
5675    }
5676    pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self {
5677        self.inner.min_sample_shading = min_sample_shading;
5678        self
5679    }
5680    #[doc = r" Sets `p_sample_mask` to `null` if the slice is empty. The mask will"]
5681    #[doc = r" be treated as if it has all bits set to `1`."]
5682    #[doc = r""]
5683    #[doc = r" See <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html#_description>"]
5684    #[doc = r" for more details."]
5685    pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self {
5686        self.inner.p_sample_mask = if sample_mask.is_empty() {
5687            std::ptr::null()
5688        } else {
5689            sample_mask.as_ptr()
5690        };
5691        self
5692    }
5693    pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self {
5694        self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into();
5695        self
5696    }
5697    pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self {
5698        self.inner.alpha_to_one_enable = alpha_to_one_enable.into();
5699        self
5700    }
5701    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5702    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5703    #[doc = r" valid extension structs can be pushed into the chain."]
5704    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5705    #[doc = r" chain will look like `A -> D -> B -> C`."]
5706    pub fn push_next<T: ExtendsPipelineMultisampleStateCreateInfo>(
5707        mut self,
5708        next: &'a mut T,
5709    ) -> Self {
5710        unsafe {
5711            let next_ptr = <*const T>::cast(next);
5712            let last_next = ptr_chain_iter(next).last().unwrap();
5713            (*last_next).p_next = self.inner.p_next as _;
5714            self.inner.p_next = next_ptr;
5715        }
5716        self
5717    }
5718    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5719    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5720    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5721    pub fn build(self) -> PipelineMultisampleStateCreateInfo {
5722        self.inner
5723    }
5724}
5725#[repr(C)]
5726#[cfg_attr(feature = "debug", derive(Debug))]
5727#[derive(Copy, Clone, Default)]
5728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAttachmentState.html>"]
5729pub struct PipelineColorBlendAttachmentState {
5730    pub blend_enable: Bool32,
5731    pub src_color_blend_factor: BlendFactor,
5732    pub dst_color_blend_factor: BlendFactor,
5733    pub color_blend_op: BlendOp,
5734    pub src_alpha_blend_factor: BlendFactor,
5735    pub dst_alpha_blend_factor: BlendFactor,
5736    pub alpha_blend_op: BlendOp,
5737    pub color_write_mask: ColorComponentFlags,
5738}
5739impl PipelineColorBlendAttachmentState {
5740    pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> {
5741        PipelineColorBlendAttachmentStateBuilder {
5742            inner: Self::default(),
5743            marker: ::std::marker::PhantomData,
5744        }
5745    }
5746}
5747#[repr(transparent)]
5748pub struct PipelineColorBlendAttachmentStateBuilder<'a> {
5749    inner: PipelineColorBlendAttachmentState,
5750    marker: ::std::marker::PhantomData<&'a ()>,
5751}
5752impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> {
5753    type Target = PipelineColorBlendAttachmentState;
5754    fn deref(&self) -> &Self::Target {
5755        &self.inner
5756    }
5757}
5758impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> {
5759    fn deref_mut(&mut self) -> &mut Self::Target {
5760        &mut self.inner
5761    }
5762}
5763impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
5764    pub fn blend_enable(mut self, blend_enable: bool) -> Self {
5765        self.inner.blend_enable = blend_enable.into();
5766        self
5767    }
5768    pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self {
5769        self.inner.src_color_blend_factor = src_color_blend_factor;
5770        self
5771    }
5772    pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self {
5773        self.inner.dst_color_blend_factor = dst_color_blend_factor;
5774        self
5775    }
5776    pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self {
5777        self.inner.color_blend_op = color_blend_op;
5778        self
5779    }
5780    pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self {
5781        self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
5782        self
5783    }
5784    pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self {
5785        self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
5786        self
5787    }
5788    pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self {
5789        self.inner.alpha_blend_op = alpha_blend_op;
5790        self
5791    }
5792    pub fn color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self {
5793        self.inner.color_write_mask = color_write_mask;
5794        self
5795    }
5796    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5797    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5798    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5799    pub fn build(self) -> PipelineColorBlendAttachmentState {
5800        self.inner
5801    }
5802}
5803#[repr(C)]
5804#[cfg_attr(feature = "debug", derive(Debug))]
5805#[derive(Copy, Clone)]
5806#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html>"]
5807pub struct PipelineColorBlendStateCreateInfo {
5808    pub s_type: StructureType,
5809    pub p_next: *const c_void,
5810    pub flags: PipelineColorBlendStateCreateFlags,
5811    pub logic_op_enable: Bool32,
5812    pub logic_op: LogicOp,
5813    pub attachment_count: u32,
5814    pub p_attachments: *const PipelineColorBlendAttachmentState,
5815    pub blend_constants: [f32; 4],
5816}
5817impl ::std::default::Default for PipelineColorBlendStateCreateInfo {
5818    fn default() -> Self {
5819        Self {
5820            s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
5821            p_next: ::std::ptr::null(),
5822            flags: PipelineColorBlendStateCreateFlags::default(),
5823            logic_op_enable: Bool32::default(),
5824            logic_op: LogicOp::default(),
5825            attachment_count: u32::default(),
5826            p_attachments: ::std::ptr::null(),
5827            blend_constants: unsafe { ::std::mem::zeroed() },
5828        }
5829    }
5830}
5831impl PipelineColorBlendStateCreateInfo {
5832    pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
5833        PipelineColorBlendStateCreateInfoBuilder {
5834            inner: Self::default(),
5835            marker: ::std::marker::PhantomData,
5836        }
5837    }
5838}
5839#[repr(transparent)]
5840pub struct PipelineColorBlendStateCreateInfoBuilder<'a> {
5841    inner: PipelineColorBlendStateCreateInfo,
5842    marker: ::std::marker::PhantomData<&'a ()>,
5843}
5844pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {}
5845impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
5846    type Target = PipelineColorBlendStateCreateInfo;
5847    fn deref(&self) -> &Self::Target {
5848        &self.inner
5849    }
5850}
5851impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
5852    fn deref_mut(&mut self) -> &mut Self::Target {
5853        &mut self.inner
5854    }
5855}
5856impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
5857    pub fn flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self {
5858        self.inner.flags = flags;
5859        self
5860    }
5861    pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self {
5862        self.inner.logic_op_enable = logic_op_enable.into();
5863        self
5864    }
5865    pub fn logic_op(mut self, logic_op: LogicOp) -> Self {
5866        self.inner.logic_op = logic_op;
5867        self
5868    }
5869    pub fn attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self {
5870        self.inner.attachment_count = attachments.len() as _;
5871        self.inner.p_attachments = attachments.as_ptr();
5872        self
5873    }
5874    pub fn blend_constants(mut self, blend_constants: [f32; 4]) -> Self {
5875        self.inner.blend_constants = blend_constants;
5876        self
5877    }
5878    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5879    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5880    #[doc = r" valid extension structs can be pushed into the chain."]
5881    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5882    #[doc = r" chain will look like `A -> D -> B -> C`."]
5883    pub fn push_next<T: ExtendsPipelineColorBlendStateCreateInfo>(
5884        mut self,
5885        next: &'a mut T,
5886    ) -> Self {
5887        unsafe {
5888            let next_ptr = <*const T>::cast(next);
5889            let last_next = ptr_chain_iter(next).last().unwrap();
5890            (*last_next).p_next = self.inner.p_next as _;
5891            self.inner.p_next = next_ptr;
5892        }
5893        self
5894    }
5895    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5896    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5897    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5898    pub fn build(self) -> PipelineColorBlendStateCreateInfo {
5899        self.inner
5900    }
5901}
5902#[repr(C)]
5903#[cfg_attr(feature = "debug", derive(Debug))]
5904#[derive(Copy, Clone)]
5905#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateInfo.html>"]
5906pub struct PipelineDynamicStateCreateInfo {
5907    pub s_type: StructureType,
5908    pub p_next: *const c_void,
5909    pub flags: PipelineDynamicStateCreateFlags,
5910    pub dynamic_state_count: u32,
5911    pub p_dynamic_states: *const DynamicState,
5912}
5913impl ::std::default::Default for PipelineDynamicStateCreateInfo {
5914    fn default() -> Self {
5915        Self {
5916            s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO,
5917            p_next: ::std::ptr::null(),
5918            flags: PipelineDynamicStateCreateFlags::default(),
5919            dynamic_state_count: u32::default(),
5920            p_dynamic_states: ::std::ptr::null(),
5921        }
5922    }
5923}
5924impl PipelineDynamicStateCreateInfo {
5925    pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> {
5926        PipelineDynamicStateCreateInfoBuilder {
5927            inner: Self::default(),
5928            marker: ::std::marker::PhantomData,
5929        }
5930    }
5931}
5932#[repr(transparent)]
5933pub struct PipelineDynamicStateCreateInfoBuilder<'a> {
5934    inner: PipelineDynamicStateCreateInfo,
5935    marker: ::std::marker::PhantomData<&'a ()>,
5936}
5937impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
5938    type Target = PipelineDynamicStateCreateInfo;
5939    fn deref(&self) -> &Self::Target {
5940        &self.inner
5941    }
5942}
5943impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
5944    fn deref_mut(&mut self) -> &mut Self::Target {
5945        &mut self.inner
5946    }
5947}
5948impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
5949    pub fn flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self {
5950        self.inner.flags = flags;
5951        self
5952    }
5953    pub fn dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self {
5954        self.inner.dynamic_state_count = dynamic_states.len() as _;
5955        self.inner.p_dynamic_states = dynamic_states.as_ptr();
5956        self
5957    }
5958    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5959    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5960    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
5961    pub fn build(self) -> PipelineDynamicStateCreateInfo {
5962        self.inner
5963    }
5964}
5965#[repr(C)]
5966#[cfg_attr(feature = "debug", derive(Debug))]
5967#[derive(Copy, Clone, Default)]
5968#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilOpState.html>"]
5969pub struct StencilOpState {
5970    pub fail_op: StencilOp,
5971    pub pass_op: StencilOp,
5972    pub depth_fail_op: StencilOp,
5973    pub compare_op: CompareOp,
5974    pub compare_mask: u32,
5975    pub write_mask: u32,
5976    pub reference: u32,
5977}
5978impl StencilOpState {
5979    pub fn builder<'a>() -> StencilOpStateBuilder<'a> {
5980        StencilOpStateBuilder {
5981            inner: Self::default(),
5982            marker: ::std::marker::PhantomData,
5983        }
5984    }
5985}
5986#[repr(transparent)]
5987pub struct StencilOpStateBuilder<'a> {
5988    inner: StencilOpState,
5989    marker: ::std::marker::PhantomData<&'a ()>,
5990}
5991impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> {
5992    type Target = StencilOpState;
5993    fn deref(&self) -> &Self::Target {
5994        &self.inner
5995    }
5996}
5997impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> {
5998    fn deref_mut(&mut self) -> &mut Self::Target {
5999        &mut self.inner
6000    }
6001}
6002impl<'a> StencilOpStateBuilder<'a> {
6003    pub fn fail_op(mut self, fail_op: StencilOp) -> Self {
6004        self.inner.fail_op = fail_op;
6005        self
6006    }
6007    pub fn pass_op(mut self, pass_op: StencilOp) -> Self {
6008        self.inner.pass_op = pass_op;
6009        self
6010    }
6011    pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self {
6012        self.inner.depth_fail_op = depth_fail_op;
6013        self
6014    }
6015    pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
6016        self.inner.compare_op = compare_op;
6017        self
6018    }
6019    pub fn compare_mask(mut self, compare_mask: u32) -> Self {
6020        self.inner.compare_mask = compare_mask;
6021        self
6022    }
6023    pub fn write_mask(mut self, write_mask: u32) -> Self {
6024        self.inner.write_mask = write_mask;
6025        self
6026    }
6027    pub fn reference(mut self, reference: u32) -> Self {
6028        self.inner.reference = reference;
6029        self
6030    }
6031    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6032    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6033    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6034    pub fn build(self) -> StencilOpState {
6035        self.inner
6036    }
6037}
6038#[repr(C)]
6039#[cfg_attr(feature = "debug", derive(Debug))]
6040#[derive(Copy, Clone)]
6041#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html>"]
6042pub struct PipelineDepthStencilStateCreateInfo {
6043    pub s_type: StructureType,
6044    pub p_next: *const c_void,
6045    pub flags: PipelineDepthStencilStateCreateFlags,
6046    pub depth_test_enable: Bool32,
6047    pub depth_write_enable: Bool32,
6048    pub depth_compare_op: CompareOp,
6049    pub depth_bounds_test_enable: Bool32,
6050    pub stencil_test_enable: Bool32,
6051    pub front: StencilOpState,
6052    pub back: StencilOpState,
6053    pub min_depth_bounds: f32,
6054    pub max_depth_bounds: f32,
6055}
6056impl ::std::default::Default for PipelineDepthStencilStateCreateInfo {
6057    fn default() -> Self {
6058        Self {
6059            s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
6060            p_next: ::std::ptr::null(),
6061            flags: PipelineDepthStencilStateCreateFlags::default(),
6062            depth_test_enable: Bool32::default(),
6063            depth_write_enable: Bool32::default(),
6064            depth_compare_op: CompareOp::default(),
6065            depth_bounds_test_enable: Bool32::default(),
6066            stencil_test_enable: Bool32::default(),
6067            front: StencilOpState::default(),
6068            back: StencilOpState::default(),
6069            min_depth_bounds: f32::default(),
6070            max_depth_bounds: f32::default(),
6071        }
6072    }
6073}
6074impl PipelineDepthStencilStateCreateInfo {
6075    pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6076        PipelineDepthStencilStateCreateInfoBuilder {
6077            inner: Self::default(),
6078            marker: ::std::marker::PhantomData,
6079        }
6080    }
6081}
6082#[repr(transparent)]
6083pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> {
6084    inner: PipelineDepthStencilStateCreateInfo,
6085    marker: ::std::marker::PhantomData<&'a ()>,
6086}
6087impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
6088    type Target = PipelineDepthStencilStateCreateInfo;
6089    fn deref(&self) -> &Self::Target {
6090        &self.inner
6091    }
6092}
6093impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> {
6094    fn deref_mut(&mut self) -> &mut Self::Target {
6095        &mut self.inner
6096    }
6097}
6098impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6099    pub fn flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self {
6100        self.inner.flags = flags;
6101        self
6102    }
6103    pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self {
6104        self.inner.depth_test_enable = depth_test_enable.into();
6105        self
6106    }
6107    pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self {
6108        self.inner.depth_write_enable = depth_write_enable.into();
6109        self
6110    }
6111    pub fn depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self {
6112        self.inner.depth_compare_op = depth_compare_op;
6113        self
6114    }
6115    pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self {
6116        self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into();
6117        self
6118    }
6119    pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self {
6120        self.inner.stencil_test_enable = stencil_test_enable.into();
6121        self
6122    }
6123    pub fn front(mut self, front: StencilOpState) -> Self {
6124        self.inner.front = front;
6125        self
6126    }
6127    pub fn back(mut self, back: StencilOpState) -> Self {
6128        self.inner.back = back;
6129        self
6130    }
6131    pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self {
6132        self.inner.min_depth_bounds = min_depth_bounds;
6133        self
6134    }
6135    pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self {
6136        self.inner.max_depth_bounds = max_depth_bounds;
6137        self
6138    }
6139    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6140    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6141    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6142    pub fn build(self) -> PipelineDepthStencilStateCreateInfo {
6143        self.inner
6144    }
6145}
6146#[repr(C)]
6147#[cfg_attr(feature = "debug", derive(Debug))]
6148#[derive(Copy, Clone)]
6149#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html>"]
6150pub struct GraphicsPipelineCreateInfo {
6151    pub s_type: StructureType,
6152    pub p_next: *const c_void,
6153    pub flags: PipelineCreateFlags,
6154    pub stage_count: u32,
6155    pub p_stages: *const PipelineShaderStageCreateInfo,
6156    pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
6157    pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo,
6158    pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
6159    pub p_viewport_state: *const PipelineViewportStateCreateInfo,
6160    pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo,
6161    pub p_multisample_state: *const PipelineMultisampleStateCreateInfo,
6162    pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo,
6163    pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo,
6164    pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
6165    pub layout: PipelineLayout,
6166    pub render_pass: RenderPass,
6167    pub subpass: u32,
6168    pub base_pipeline_handle: Pipeline,
6169    pub base_pipeline_index: i32,
6170}
6171impl ::std::default::Default for GraphicsPipelineCreateInfo {
6172    fn default() -> Self {
6173        Self {
6174            s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO,
6175            p_next: ::std::ptr::null(),
6176            flags: PipelineCreateFlags::default(),
6177            stage_count: u32::default(),
6178            p_stages: ::std::ptr::null(),
6179            p_vertex_input_state: ::std::ptr::null(),
6180            p_input_assembly_state: ::std::ptr::null(),
6181            p_tessellation_state: ::std::ptr::null(),
6182            p_viewport_state: ::std::ptr::null(),
6183            p_rasterization_state: ::std::ptr::null(),
6184            p_multisample_state: ::std::ptr::null(),
6185            p_depth_stencil_state: ::std::ptr::null(),
6186            p_color_blend_state: ::std::ptr::null(),
6187            p_dynamic_state: ::std::ptr::null(),
6188            layout: PipelineLayout::default(),
6189            render_pass: RenderPass::default(),
6190            subpass: u32::default(),
6191            base_pipeline_handle: Pipeline::default(),
6192            base_pipeline_index: i32::default(),
6193        }
6194    }
6195}
6196impl GraphicsPipelineCreateInfo {
6197    pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> {
6198        GraphicsPipelineCreateInfoBuilder {
6199            inner: Self::default(),
6200            marker: ::std::marker::PhantomData,
6201        }
6202    }
6203}
6204#[repr(transparent)]
6205pub struct GraphicsPipelineCreateInfoBuilder<'a> {
6206    inner: GraphicsPipelineCreateInfo,
6207    marker: ::std::marker::PhantomData<&'a ()>,
6208}
6209pub unsafe trait ExtendsGraphicsPipelineCreateInfo {}
6210impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> {
6211    type Target = GraphicsPipelineCreateInfo;
6212    fn deref(&self) -> &Self::Target {
6213        &self.inner
6214    }
6215}
6216impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
6217    fn deref_mut(&mut self) -> &mut Self::Target {
6218        &mut self.inner
6219    }
6220}
6221impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
6222    pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
6223        self.inner.flags = flags;
6224        self
6225    }
6226    pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
6227        self.inner.stage_count = stages.len() as _;
6228        self.inner.p_stages = stages.as_ptr();
6229        self
6230    }
6231    pub fn vertex_input_state(
6232        mut self,
6233        vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
6234    ) -> Self {
6235        self.inner.p_vertex_input_state = vertex_input_state;
6236        self
6237    }
6238    pub fn input_assembly_state(
6239        mut self,
6240        input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo,
6241    ) -> Self {
6242        self.inner.p_input_assembly_state = input_assembly_state;
6243        self
6244    }
6245    pub fn tessellation_state(
6246        mut self,
6247        tessellation_state: &'a PipelineTessellationStateCreateInfo,
6248    ) -> Self {
6249        self.inner.p_tessellation_state = tessellation_state;
6250        self
6251    }
6252    pub fn viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self {
6253        self.inner.p_viewport_state = viewport_state;
6254        self
6255    }
6256    pub fn rasterization_state(
6257        mut self,
6258        rasterization_state: &'a PipelineRasterizationStateCreateInfo,
6259    ) -> Self {
6260        self.inner.p_rasterization_state = rasterization_state;
6261        self
6262    }
6263    pub fn multisample_state(
6264        mut self,
6265        multisample_state: &'a PipelineMultisampleStateCreateInfo,
6266    ) -> Self {
6267        self.inner.p_multisample_state = multisample_state;
6268        self
6269    }
6270    pub fn depth_stencil_state(
6271        mut self,
6272        depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo,
6273    ) -> Self {
6274        self.inner.p_depth_stencil_state = depth_stencil_state;
6275        self
6276    }
6277    pub fn color_blend_state(
6278        mut self,
6279        color_blend_state: &'a PipelineColorBlendStateCreateInfo,
6280    ) -> Self {
6281        self.inner.p_color_blend_state = color_blend_state;
6282        self
6283    }
6284    pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
6285        self.inner.p_dynamic_state = dynamic_state;
6286        self
6287    }
6288    pub fn layout(mut self, layout: PipelineLayout) -> Self {
6289        self.inner.layout = layout;
6290        self
6291    }
6292    pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
6293        self.inner.render_pass = render_pass;
6294        self
6295    }
6296    pub fn subpass(mut self, subpass: u32) -> Self {
6297        self.inner.subpass = subpass;
6298        self
6299    }
6300    pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
6301        self.inner.base_pipeline_handle = base_pipeline_handle;
6302        self
6303    }
6304    pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
6305        self.inner.base_pipeline_index = base_pipeline_index;
6306        self
6307    }
6308    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6309    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6310    #[doc = r" valid extension structs can be pushed into the chain."]
6311    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6312    #[doc = r" chain will look like `A -> D -> B -> C`."]
6313    pub fn push_next<T: ExtendsGraphicsPipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
6314        unsafe {
6315            let next_ptr = <*const T>::cast(next);
6316            let last_next = ptr_chain_iter(next).last().unwrap();
6317            (*last_next).p_next = self.inner.p_next as _;
6318            self.inner.p_next = next_ptr;
6319        }
6320        self
6321    }
6322    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6323    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6324    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6325    pub fn build(self) -> GraphicsPipelineCreateInfo {
6326        self.inner
6327    }
6328}
6329#[repr(C)]
6330#[cfg_attr(feature = "debug", derive(Debug))]
6331#[derive(Copy, Clone)]
6332#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateInfo.html>"]
6333pub struct PipelineCacheCreateInfo {
6334    pub s_type: StructureType,
6335    pub p_next: *const c_void,
6336    pub flags: PipelineCacheCreateFlags,
6337    pub initial_data_size: usize,
6338    pub p_initial_data: *const c_void,
6339}
6340impl ::std::default::Default for PipelineCacheCreateInfo {
6341    fn default() -> Self {
6342        Self {
6343            s_type: StructureType::PIPELINE_CACHE_CREATE_INFO,
6344            p_next: ::std::ptr::null(),
6345            flags: PipelineCacheCreateFlags::default(),
6346            initial_data_size: usize::default(),
6347            p_initial_data: ::std::ptr::null(),
6348        }
6349    }
6350}
6351impl PipelineCacheCreateInfo {
6352    pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> {
6353        PipelineCacheCreateInfoBuilder {
6354            inner: Self::default(),
6355            marker: ::std::marker::PhantomData,
6356        }
6357    }
6358}
6359#[repr(transparent)]
6360pub struct PipelineCacheCreateInfoBuilder<'a> {
6361    inner: PipelineCacheCreateInfo,
6362    marker: ::std::marker::PhantomData<&'a ()>,
6363}
6364impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> {
6365    type Target = PipelineCacheCreateInfo;
6366    fn deref(&self) -> &Self::Target {
6367        &self.inner
6368    }
6369}
6370impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
6371    fn deref_mut(&mut self) -> &mut Self::Target {
6372        &mut self.inner
6373    }
6374}
6375impl<'a> PipelineCacheCreateInfoBuilder<'a> {
6376    pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> Self {
6377        self.inner.flags = flags;
6378        self
6379    }
6380    pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
6381        self.inner.initial_data_size = initial_data.len();
6382        self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
6383        self
6384    }
6385    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6386    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6387    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6388    pub fn build(self) -> PipelineCacheCreateInfo {
6389        self.inner
6390    }
6391}
6392#[repr(C)]
6393#[cfg_attr(feature = "debug", derive(Debug))]
6394#[derive(Copy, Clone)]
6395#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheHeaderVersionOne.html>"]
6396pub struct PipelineCacheHeaderVersionOne {
6397    pub header_size: u32,
6398    pub header_version: PipelineCacheHeaderVersion,
6399    pub vendor_id: u32,
6400    pub device_id: u32,
6401    pub pipeline_cache_uuid: [u8; UUID_SIZE],
6402}
6403impl ::std::default::Default for PipelineCacheHeaderVersionOne {
6404    fn default() -> Self {
6405        Self {
6406            header_size: u32::default(),
6407            header_version: PipelineCacheHeaderVersion::default(),
6408            vendor_id: u32::default(),
6409            device_id: u32::default(),
6410            pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
6411        }
6412    }
6413}
6414impl PipelineCacheHeaderVersionOne {
6415    pub fn builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a> {
6416        PipelineCacheHeaderVersionOneBuilder {
6417            inner: Self::default(),
6418            marker: ::std::marker::PhantomData,
6419        }
6420    }
6421}
6422#[repr(transparent)]
6423pub struct PipelineCacheHeaderVersionOneBuilder<'a> {
6424    inner: PipelineCacheHeaderVersionOne,
6425    marker: ::std::marker::PhantomData<&'a ()>,
6426}
6427impl<'a> ::std::ops::Deref for PipelineCacheHeaderVersionOneBuilder<'a> {
6428    type Target = PipelineCacheHeaderVersionOne;
6429    fn deref(&self) -> &Self::Target {
6430        &self.inner
6431    }
6432}
6433impl<'a> ::std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> {
6434    fn deref_mut(&mut self) -> &mut Self::Target {
6435        &mut self.inner
6436    }
6437}
6438impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> {
6439    pub fn header_size(mut self, header_size: u32) -> Self {
6440        self.inner.header_size = header_size;
6441        self
6442    }
6443    pub fn header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self {
6444        self.inner.header_version = header_version;
6445        self
6446    }
6447    pub fn vendor_id(mut self, vendor_id: u32) -> Self {
6448        self.inner.vendor_id = vendor_id;
6449        self
6450    }
6451    pub fn device_id(mut self, device_id: u32) -> Self {
6452        self.inner.device_id = device_id;
6453        self
6454    }
6455    pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
6456        self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
6457        self
6458    }
6459    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6460    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6461    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6462    pub fn build(self) -> PipelineCacheHeaderVersionOne {
6463        self.inner
6464    }
6465}
6466#[repr(C)]
6467#[cfg_attr(feature = "debug", derive(Debug))]
6468#[derive(Copy, Clone, Default)]
6469#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPushConstantRange.html>"]
6470pub struct PushConstantRange {
6471    pub stage_flags: ShaderStageFlags,
6472    pub offset: u32,
6473    pub size: u32,
6474}
6475impl PushConstantRange {
6476    pub fn builder<'a>() -> PushConstantRangeBuilder<'a> {
6477        PushConstantRangeBuilder {
6478            inner: Self::default(),
6479            marker: ::std::marker::PhantomData,
6480        }
6481    }
6482}
6483#[repr(transparent)]
6484pub struct PushConstantRangeBuilder<'a> {
6485    inner: PushConstantRange,
6486    marker: ::std::marker::PhantomData<&'a ()>,
6487}
6488impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> {
6489    type Target = PushConstantRange;
6490    fn deref(&self) -> &Self::Target {
6491        &self.inner
6492    }
6493}
6494impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> {
6495    fn deref_mut(&mut self) -> &mut Self::Target {
6496        &mut self.inner
6497    }
6498}
6499impl<'a> PushConstantRangeBuilder<'a> {
6500    pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
6501        self.inner.stage_flags = stage_flags;
6502        self
6503    }
6504    pub fn offset(mut self, offset: u32) -> Self {
6505        self.inner.offset = offset;
6506        self
6507    }
6508    pub fn size(mut self, size: u32) -> Self {
6509        self.inner.size = size;
6510        self
6511    }
6512    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6513    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6514    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6515    pub fn build(self) -> PushConstantRange {
6516        self.inner
6517    }
6518}
6519#[repr(C)]
6520#[cfg_attr(feature = "debug", derive(Debug))]
6521#[derive(Copy, Clone)]
6522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateInfo.html>"]
6523pub struct PipelineLayoutCreateInfo {
6524    pub s_type: StructureType,
6525    pub p_next: *const c_void,
6526    pub flags: PipelineLayoutCreateFlags,
6527    pub set_layout_count: u32,
6528    pub p_set_layouts: *const DescriptorSetLayout,
6529    pub push_constant_range_count: u32,
6530    pub p_push_constant_ranges: *const PushConstantRange,
6531}
6532impl ::std::default::Default for PipelineLayoutCreateInfo {
6533    fn default() -> Self {
6534        Self {
6535            s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO,
6536            p_next: ::std::ptr::null(),
6537            flags: PipelineLayoutCreateFlags::default(),
6538            set_layout_count: u32::default(),
6539            p_set_layouts: ::std::ptr::null(),
6540            push_constant_range_count: u32::default(),
6541            p_push_constant_ranges: ::std::ptr::null(),
6542        }
6543    }
6544}
6545impl PipelineLayoutCreateInfo {
6546    pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> {
6547        PipelineLayoutCreateInfoBuilder {
6548            inner: Self::default(),
6549            marker: ::std::marker::PhantomData,
6550        }
6551    }
6552}
6553#[repr(transparent)]
6554pub struct PipelineLayoutCreateInfoBuilder<'a> {
6555    inner: PipelineLayoutCreateInfo,
6556    marker: ::std::marker::PhantomData<&'a ()>,
6557}
6558impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> {
6559    type Target = PipelineLayoutCreateInfo;
6560    fn deref(&self) -> &Self::Target {
6561        &self.inner
6562    }
6563}
6564impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
6565    fn deref_mut(&mut self) -> &mut Self::Target {
6566        &mut self.inner
6567    }
6568}
6569impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
6570    pub fn flags(mut self, flags: PipelineLayoutCreateFlags) -> Self {
6571        self.inner.flags = flags;
6572        self
6573    }
6574    pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
6575        self.inner.set_layout_count = set_layouts.len() as _;
6576        self.inner.p_set_layouts = set_layouts.as_ptr();
6577        self
6578    }
6579    pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self {
6580        self.inner.push_constant_range_count = push_constant_ranges.len() as _;
6581        self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
6582        self
6583    }
6584    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6585    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6586    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6587    pub fn build(self) -> PipelineLayoutCreateInfo {
6588        self.inner
6589    }
6590}
6591#[repr(C)]
6592#[cfg_attr(feature = "debug", derive(Debug))]
6593#[derive(Copy, Clone)]
6594#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateInfo.html>"]
6595pub struct SamplerCreateInfo {
6596    pub s_type: StructureType,
6597    pub p_next: *const c_void,
6598    pub flags: SamplerCreateFlags,
6599    pub mag_filter: Filter,
6600    pub min_filter: Filter,
6601    pub mipmap_mode: SamplerMipmapMode,
6602    pub address_mode_u: SamplerAddressMode,
6603    pub address_mode_v: SamplerAddressMode,
6604    pub address_mode_w: SamplerAddressMode,
6605    pub mip_lod_bias: f32,
6606    pub anisotropy_enable: Bool32,
6607    pub max_anisotropy: f32,
6608    pub compare_enable: Bool32,
6609    pub compare_op: CompareOp,
6610    pub min_lod: f32,
6611    pub max_lod: f32,
6612    pub border_color: BorderColor,
6613    pub unnormalized_coordinates: Bool32,
6614}
6615impl ::std::default::Default for SamplerCreateInfo {
6616    fn default() -> Self {
6617        Self {
6618            s_type: StructureType::SAMPLER_CREATE_INFO,
6619            p_next: ::std::ptr::null(),
6620            flags: SamplerCreateFlags::default(),
6621            mag_filter: Filter::default(),
6622            min_filter: Filter::default(),
6623            mipmap_mode: SamplerMipmapMode::default(),
6624            address_mode_u: SamplerAddressMode::default(),
6625            address_mode_v: SamplerAddressMode::default(),
6626            address_mode_w: SamplerAddressMode::default(),
6627            mip_lod_bias: f32::default(),
6628            anisotropy_enable: Bool32::default(),
6629            max_anisotropy: f32::default(),
6630            compare_enable: Bool32::default(),
6631            compare_op: CompareOp::default(),
6632            min_lod: f32::default(),
6633            max_lod: f32::default(),
6634            border_color: BorderColor::default(),
6635            unnormalized_coordinates: Bool32::default(),
6636        }
6637    }
6638}
6639impl SamplerCreateInfo {
6640    pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> {
6641        SamplerCreateInfoBuilder {
6642            inner: Self::default(),
6643            marker: ::std::marker::PhantomData,
6644        }
6645    }
6646}
6647#[repr(transparent)]
6648pub struct SamplerCreateInfoBuilder<'a> {
6649    inner: SamplerCreateInfo,
6650    marker: ::std::marker::PhantomData<&'a ()>,
6651}
6652pub unsafe trait ExtendsSamplerCreateInfo {}
6653impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> {
6654    type Target = SamplerCreateInfo;
6655    fn deref(&self) -> &Self::Target {
6656        &self.inner
6657    }
6658}
6659impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
6660    fn deref_mut(&mut self) -> &mut Self::Target {
6661        &mut self.inner
6662    }
6663}
6664impl<'a> SamplerCreateInfoBuilder<'a> {
6665    pub fn flags(mut self, flags: SamplerCreateFlags) -> Self {
6666        self.inner.flags = flags;
6667        self
6668    }
6669    pub fn mag_filter(mut self, mag_filter: Filter) -> Self {
6670        self.inner.mag_filter = mag_filter;
6671        self
6672    }
6673    pub fn min_filter(mut self, min_filter: Filter) -> Self {
6674        self.inner.min_filter = min_filter;
6675        self
6676    }
6677    pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self {
6678        self.inner.mipmap_mode = mipmap_mode;
6679        self
6680    }
6681    pub fn address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self {
6682        self.inner.address_mode_u = address_mode_u;
6683        self
6684    }
6685    pub fn address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self {
6686        self.inner.address_mode_v = address_mode_v;
6687        self
6688    }
6689    pub fn address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self {
6690        self.inner.address_mode_w = address_mode_w;
6691        self
6692    }
6693    pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self {
6694        self.inner.mip_lod_bias = mip_lod_bias;
6695        self
6696    }
6697    pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self {
6698        self.inner.anisotropy_enable = anisotropy_enable.into();
6699        self
6700    }
6701    pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self {
6702        self.inner.max_anisotropy = max_anisotropy;
6703        self
6704    }
6705    pub fn compare_enable(mut self, compare_enable: bool) -> Self {
6706        self.inner.compare_enable = compare_enable.into();
6707        self
6708    }
6709    pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
6710        self.inner.compare_op = compare_op;
6711        self
6712    }
6713    pub fn min_lod(mut self, min_lod: f32) -> Self {
6714        self.inner.min_lod = min_lod;
6715        self
6716    }
6717    pub fn max_lod(mut self, max_lod: f32) -> Self {
6718        self.inner.max_lod = max_lod;
6719        self
6720    }
6721    pub fn border_color(mut self, border_color: BorderColor) -> Self {
6722        self.inner.border_color = border_color;
6723        self
6724    }
6725    pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self {
6726        self.inner.unnormalized_coordinates = unnormalized_coordinates.into();
6727        self
6728    }
6729    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6730    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6731    #[doc = r" valid extension structs can be pushed into the chain."]
6732    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6733    #[doc = r" chain will look like `A -> D -> B -> C`."]
6734    pub fn push_next<T: ExtendsSamplerCreateInfo>(mut self, next: &'a mut T) -> Self {
6735        unsafe {
6736            let next_ptr = <*const T>::cast(next);
6737            let last_next = ptr_chain_iter(next).last().unwrap();
6738            (*last_next).p_next = self.inner.p_next as _;
6739            self.inner.p_next = next_ptr;
6740        }
6741        self
6742    }
6743    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6744    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6745    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6746    pub fn build(self) -> SamplerCreateInfo {
6747        self.inner
6748    }
6749}
6750#[repr(C)]
6751#[cfg_attr(feature = "debug", derive(Debug))]
6752#[derive(Copy, Clone)]
6753#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateInfo.html>"]
6754pub struct CommandPoolCreateInfo {
6755    pub s_type: StructureType,
6756    pub p_next: *const c_void,
6757    pub flags: CommandPoolCreateFlags,
6758    pub queue_family_index: u32,
6759}
6760impl ::std::default::Default for CommandPoolCreateInfo {
6761    fn default() -> Self {
6762        Self {
6763            s_type: StructureType::COMMAND_POOL_CREATE_INFO,
6764            p_next: ::std::ptr::null(),
6765            flags: CommandPoolCreateFlags::default(),
6766            queue_family_index: u32::default(),
6767        }
6768    }
6769}
6770impl CommandPoolCreateInfo {
6771    pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> {
6772        CommandPoolCreateInfoBuilder {
6773            inner: Self::default(),
6774            marker: ::std::marker::PhantomData,
6775        }
6776    }
6777}
6778#[repr(transparent)]
6779pub struct CommandPoolCreateInfoBuilder<'a> {
6780    inner: CommandPoolCreateInfo,
6781    marker: ::std::marker::PhantomData<&'a ()>,
6782}
6783impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> {
6784    type Target = CommandPoolCreateInfo;
6785    fn deref(&self) -> &Self::Target {
6786        &self.inner
6787    }
6788}
6789impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
6790    fn deref_mut(&mut self) -> &mut Self::Target {
6791        &mut self.inner
6792    }
6793}
6794impl<'a> CommandPoolCreateInfoBuilder<'a> {
6795    pub fn flags(mut self, flags: CommandPoolCreateFlags) -> Self {
6796        self.inner.flags = flags;
6797        self
6798    }
6799    pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
6800        self.inner.queue_family_index = queue_family_index;
6801        self
6802    }
6803    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6804    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6805    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6806    pub fn build(self) -> CommandPoolCreateInfo {
6807        self.inner
6808    }
6809}
6810#[repr(C)]
6811#[cfg_attr(feature = "debug", derive(Debug))]
6812#[derive(Copy, Clone)]
6813#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferAllocateInfo.html>"]
6814pub struct CommandBufferAllocateInfo {
6815    pub s_type: StructureType,
6816    pub p_next: *const c_void,
6817    pub command_pool: CommandPool,
6818    pub level: CommandBufferLevel,
6819    pub command_buffer_count: u32,
6820}
6821impl ::std::default::Default for CommandBufferAllocateInfo {
6822    fn default() -> Self {
6823        Self {
6824            s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO,
6825            p_next: ::std::ptr::null(),
6826            command_pool: CommandPool::default(),
6827            level: CommandBufferLevel::default(),
6828            command_buffer_count: u32::default(),
6829        }
6830    }
6831}
6832impl CommandBufferAllocateInfo {
6833    pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> {
6834        CommandBufferAllocateInfoBuilder {
6835            inner: Self::default(),
6836            marker: ::std::marker::PhantomData,
6837        }
6838    }
6839}
6840#[repr(transparent)]
6841pub struct CommandBufferAllocateInfoBuilder<'a> {
6842    inner: CommandBufferAllocateInfo,
6843    marker: ::std::marker::PhantomData<&'a ()>,
6844}
6845impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> {
6846    type Target = CommandBufferAllocateInfo;
6847    fn deref(&self) -> &Self::Target {
6848        &self.inner
6849    }
6850}
6851impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
6852    fn deref_mut(&mut self) -> &mut Self::Target {
6853        &mut self.inner
6854    }
6855}
6856impl<'a> CommandBufferAllocateInfoBuilder<'a> {
6857    pub fn command_pool(mut self, command_pool: CommandPool) -> Self {
6858        self.inner.command_pool = command_pool;
6859        self
6860    }
6861    pub fn level(mut self, level: CommandBufferLevel) -> Self {
6862        self.inner.level = level;
6863        self
6864    }
6865    pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self {
6866        self.inner.command_buffer_count = command_buffer_count;
6867        self
6868    }
6869    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6870    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6871    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6872    pub fn build(self) -> CommandBufferAllocateInfo {
6873        self.inner
6874    }
6875}
6876#[repr(C)]
6877#[cfg_attr(feature = "debug", derive(Debug))]
6878#[derive(Copy, Clone)]
6879#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceInfo.html>"]
6880pub struct CommandBufferInheritanceInfo {
6881    pub s_type: StructureType,
6882    pub p_next: *const c_void,
6883    pub render_pass: RenderPass,
6884    pub subpass: u32,
6885    pub framebuffer: Framebuffer,
6886    pub occlusion_query_enable: Bool32,
6887    pub query_flags: QueryControlFlags,
6888    pub pipeline_statistics: QueryPipelineStatisticFlags,
6889}
6890impl ::std::default::Default for CommandBufferInheritanceInfo {
6891    fn default() -> Self {
6892        Self {
6893            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO,
6894            p_next: ::std::ptr::null(),
6895            render_pass: RenderPass::default(),
6896            subpass: u32::default(),
6897            framebuffer: Framebuffer::default(),
6898            occlusion_query_enable: Bool32::default(),
6899            query_flags: QueryControlFlags::default(),
6900            pipeline_statistics: QueryPipelineStatisticFlags::default(),
6901        }
6902    }
6903}
6904impl CommandBufferInheritanceInfo {
6905    pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> {
6906        CommandBufferInheritanceInfoBuilder {
6907            inner: Self::default(),
6908            marker: ::std::marker::PhantomData,
6909        }
6910    }
6911}
6912#[repr(transparent)]
6913pub struct CommandBufferInheritanceInfoBuilder<'a> {
6914    inner: CommandBufferInheritanceInfo,
6915    marker: ::std::marker::PhantomData<&'a ()>,
6916}
6917pub unsafe trait ExtendsCommandBufferInheritanceInfo {}
6918impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> {
6919    type Target = CommandBufferInheritanceInfo;
6920    fn deref(&self) -> &Self::Target {
6921        &self.inner
6922    }
6923}
6924impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
6925    fn deref_mut(&mut self) -> &mut Self::Target {
6926        &mut self.inner
6927    }
6928}
6929impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
6930    pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
6931        self.inner.render_pass = render_pass;
6932        self
6933    }
6934    pub fn subpass(mut self, subpass: u32) -> Self {
6935        self.inner.subpass = subpass;
6936        self
6937    }
6938    pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
6939        self.inner.framebuffer = framebuffer;
6940        self
6941    }
6942    pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self {
6943        self.inner.occlusion_query_enable = occlusion_query_enable.into();
6944        self
6945    }
6946    pub fn query_flags(mut self, query_flags: QueryControlFlags) -> Self {
6947        self.inner.query_flags = query_flags;
6948        self
6949    }
6950    pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
6951        self.inner.pipeline_statistics = pipeline_statistics;
6952        self
6953    }
6954    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6955    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6956    #[doc = r" valid extension structs can be pushed into the chain."]
6957    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6958    #[doc = r" chain will look like `A -> D -> B -> C`."]
6959    pub fn push_next<T: ExtendsCommandBufferInheritanceInfo>(mut self, next: &'a mut T) -> Self {
6960        unsafe {
6961            let next_ptr = <*const T>::cast(next);
6962            let last_next = ptr_chain_iter(next).last().unwrap();
6963            (*last_next).p_next = self.inner.p_next as _;
6964            self.inner.p_next = next_ptr;
6965        }
6966        self
6967    }
6968    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6969    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6970    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
6971    pub fn build(self) -> CommandBufferInheritanceInfo {
6972        self.inner
6973    }
6974}
6975#[repr(C)]
6976#[cfg_attr(feature = "debug", derive(Debug))]
6977#[derive(Copy, Clone)]
6978#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferBeginInfo.html>"]
6979pub struct CommandBufferBeginInfo {
6980    pub s_type: StructureType,
6981    pub p_next: *const c_void,
6982    pub flags: CommandBufferUsageFlags,
6983    pub p_inheritance_info: *const CommandBufferInheritanceInfo,
6984}
6985impl ::std::default::Default for CommandBufferBeginInfo {
6986    fn default() -> Self {
6987        Self {
6988            s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO,
6989            p_next: ::std::ptr::null(),
6990            flags: CommandBufferUsageFlags::default(),
6991            p_inheritance_info: ::std::ptr::null(),
6992        }
6993    }
6994}
6995impl CommandBufferBeginInfo {
6996    pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> {
6997        CommandBufferBeginInfoBuilder {
6998            inner: Self::default(),
6999            marker: ::std::marker::PhantomData,
7000        }
7001    }
7002}
7003#[repr(transparent)]
7004pub struct CommandBufferBeginInfoBuilder<'a> {
7005    inner: CommandBufferBeginInfo,
7006    marker: ::std::marker::PhantomData<&'a ()>,
7007}
7008pub unsafe trait ExtendsCommandBufferBeginInfo {}
7009impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> {
7010    type Target = CommandBufferBeginInfo;
7011    fn deref(&self) -> &Self::Target {
7012        &self.inner
7013    }
7014}
7015impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
7016    fn deref_mut(&mut self) -> &mut Self::Target {
7017        &mut self.inner
7018    }
7019}
7020impl<'a> CommandBufferBeginInfoBuilder<'a> {
7021    pub fn flags(mut self, flags: CommandBufferUsageFlags) -> Self {
7022        self.inner.flags = flags;
7023        self
7024    }
7025    pub fn inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self {
7026        self.inner.p_inheritance_info = inheritance_info;
7027        self
7028    }
7029    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7030    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7031    #[doc = r" valid extension structs can be pushed into the chain."]
7032    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7033    #[doc = r" chain will look like `A -> D -> B -> C`."]
7034    pub fn push_next<T: ExtendsCommandBufferBeginInfo>(mut self, next: &'a mut T) -> Self {
7035        unsafe {
7036            let next_ptr = <*const T>::cast(next);
7037            let last_next = ptr_chain_iter(next).last().unwrap();
7038            (*last_next).p_next = self.inner.p_next as _;
7039            self.inner.p_next = next_ptr;
7040        }
7041        self
7042    }
7043    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7044    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7045    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7046    pub fn build(self) -> CommandBufferBeginInfo {
7047        self.inner
7048    }
7049}
7050#[repr(C)]
7051#[derive(Copy, Clone)]
7052#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassBeginInfo.html>"]
7053pub struct RenderPassBeginInfo {
7054    pub s_type: StructureType,
7055    pub p_next: *const c_void,
7056    pub render_pass: RenderPass,
7057    pub framebuffer: Framebuffer,
7058    pub render_area: Rect2D,
7059    pub clear_value_count: u32,
7060    pub p_clear_values: *const ClearValue,
7061}
7062#[cfg(feature = "debug")]
7063impl fmt::Debug for RenderPassBeginInfo {
7064    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
7065        fmt.debug_struct("RenderPassBeginInfo")
7066            .field("s_type", &self.s_type)
7067            .field("p_next", &self.p_next)
7068            .field("render_pass", &self.render_pass)
7069            .field("framebuffer", &self.framebuffer)
7070            .field("render_area", &self.render_area)
7071            .field("clear_value_count", &self.clear_value_count)
7072            .field("p_clear_values", &"union")
7073            .finish()
7074    }
7075}
7076impl ::std::default::Default for RenderPassBeginInfo {
7077    fn default() -> Self {
7078        Self {
7079            s_type: StructureType::RENDER_PASS_BEGIN_INFO,
7080            p_next: ::std::ptr::null(),
7081            render_pass: RenderPass::default(),
7082            framebuffer: Framebuffer::default(),
7083            render_area: Rect2D::default(),
7084            clear_value_count: u32::default(),
7085            p_clear_values: ::std::ptr::null(),
7086        }
7087    }
7088}
7089impl RenderPassBeginInfo {
7090    pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> {
7091        RenderPassBeginInfoBuilder {
7092            inner: Self::default(),
7093            marker: ::std::marker::PhantomData,
7094        }
7095    }
7096}
7097#[repr(transparent)]
7098pub struct RenderPassBeginInfoBuilder<'a> {
7099    inner: RenderPassBeginInfo,
7100    marker: ::std::marker::PhantomData<&'a ()>,
7101}
7102pub unsafe trait ExtendsRenderPassBeginInfo {}
7103impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> {
7104    type Target = RenderPassBeginInfo;
7105    fn deref(&self) -> &Self::Target {
7106        &self.inner
7107    }
7108}
7109impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
7110    fn deref_mut(&mut self) -> &mut Self::Target {
7111        &mut self.inner
7112    }
7113}
7114impl<'a> RenderPassBeginInfoBuilder<'a> {
7115    pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
7116        self.inner.render_pass = render_pass;
7117        self
7118    }
7119    pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
7120        self.inner.framebuffer = framebuffer;
7121        self
7122    }
7123    pub fn render_area(mut self, render_area: Rect2D) -> Self {
7124        self.inner.render_area = render_area;
7125        self
7126    }
7127    pub fn clear_values(mut self, clear_values: &'a [ClearValue]) -> Self {
7128        self.inner.clear_value_count = clear_values.len() as _;
7129        self.inner.p_clear_values = clear_values.as_ptr();
7130        self
7131    }
7132    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7133    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7134    #[doc = r" valid extension structs can be pushed into the chain."]
7135    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7136    #[doc = r" chain will look like `A -> D -> B -> C`."]
7137    pub fn push_next<T: ExtendsRenderPassBeginInfo>(mut self, next: &'a mut T) -> Self {
7138        unsafe {
7139            let next_ptr = <*const T>::cast(next);
7140            let last_next = ptr_chain_iter(next).last().unwrap();
7141            (*last_next).p_next = self.inner.p_next as _;
7142            self.inner.p_next = next_ptr;
7143        }
7144        self
7145    }
7146    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7147    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7148    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7149    pub fn build(self) -> RenderPassBeginInfo {
7150        self.inner
7151    }
7152}
7153#[repr(C)]
7154#[derive(Copy, Clone)]
7155#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearColorValue.html>"]
7156pub union ClearColorValue {
7157    pub float32: [f32; 4],
7158    pub int32: [i32; 4],
7159    pub uint32: [u32; 4],
7160}
7161impl ::std::default::Default for ClearColorValue {
7162    fn default() -> Self {
7163        unsafe { ::std::mem::zeroed() }
7164    }
7165}
7166#[repr(C)]
7167#[cfg_attr(feature = "debug", derive(Debug))]
7168#[derive(Copy, Clone, Default)]
7169#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearDepthStencilValue.html>"]
7170pub struct ClearDepthStencilValue {
7171    pub depth: f32,
7172    pub stencil: u32,
7173}
7174impl ClearDepthStencilValue {
7175    pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> {
7176        ClearDepthStencilValueBuilder {
7177            inner: Self::default(),
7178            marker: ::std::marker::PhantomData,
7179        }
7180    }
7181}
7182#[repr(transparent)]
7183pub struct ClearDepthStencilValueBuilder<'a> {
7184    inner: ClearDepthStencilValue,
7185    marker: ::std::marker::PhantomData<&'a ()>,
7186}
7187impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> {
7188    type Target = ClearDepthStencilValue;
7189    fn deref(&self) -> &Self::Target {
7190        &self.inner
7191    }
7192}
7193impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> {
7194    fn deref_mut(&mut self) -> &mut Self::Target {
7195        &mut self.inner
7196    }
7197}
7198impl<'a> ClearDepthStencilValueBuilder<'a> {
7199    pub fn depth(mut self, depth: f32) -> Self {
7200        self.inner.depth = depth;
7201        self
7202    }
7203    pub fn stencil(mut self, stencil: u32) -> Self {
7204        self.inner.stencil = stencil;
7205        self
7206    }
7207    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7208    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7209    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7210    pub fn build(self) -> ClearDepthStencilValue {
7211        self.inner
7212    }
7213}
7214#[repr(C)]
7215#[derive(Copy, Clone)]
7216#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearValue.html>"]
7217pub union ClearValue {
7218    pub color: ClearColorValue,
7219    pub depth_stencil: ClearDepthStencilValue,
7220}
7221impl ::std::default::Default for ClearValue {
7222    fn default() -> Self {
7223        unsafe { ::std::mem::zeroed() }
7224    }
7225}
7226#[repr(C)]
7227#[derive(Copy, Clone, Default)]
7228#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearAttachment.html>"]
7229pub struct ClearAttachment {
7230    pub aspect_mask: ImageAspectFlags,
7231    pub color_attachment: u32,
7232    pub clear_value: ClearValue,
7233}
7234#[cfg(feature = "debug")]
7235impl fmt::Debug for ClearAttachment {
7236    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
7237        fmt.debug_struct("ClearAttachment")
7238            .field("aspect_mask", &self.aspect_mask)
7239            .field("color_attachment", &self.color_attachment)
7240            .field("clear_value", &"union")
7241            .finish()
7242    }
7243}
7244impl ClearAttachment {
7245    pub fn builder<'a>() -> ClearAttachmentBuilder<'a> {
7246        ClearAttachmentBuilder {
7247            inner: Self::default(),
7248            marker: ::std::marker::PhantomData,
7249        }
7250    }
7251}
7252#[repr(transparent)]
7253pub struct ClearAttachmentBuilder<'a> {
7254    inner: ClearAttachment,
7255    marker: ::std::marker::PhantomData<&'a ()>,
7256}
7257impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> {
7258    type Target = ClearAttachment;
7259    fn deref(&self) -> &Self::Target {
7260        &self.inner
7261    }
7262}
7263impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> {
7264    fn deref_mut(&mut self) -> &mut Self::Target {
7265        &mut self.inner
7266    }
7267}
7268impl<'a> ClearAttachmentBuilder<'a> {
7269    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
7270        self.inner.aspect_mask = aspect_mask;
7271        self
7272    }
7273    pub fn color_attachment(mut self, color_attachment: u32) -> Self {
7274        self.inner.color_attachment = color_attachment;
7275        self
7276    }
7277    pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
7278        self.inner.clear_value = clear_value;
7279        self
7280    }
7281    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7282    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7283    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7284    pub fn build(self) -> ClearAttachment {
7285        self.inner
7286    }
7287}
7288#[repr(C)]
7289#[cfg_attr(feature = "debug", derive(Debug))]
7290#[derive(Copy, Clone, Default)]
7291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription.html>"]
7292pub struct AttachmentDescription {
7293    pub flags: AttachmentDescriptionFlags,
7294    pub format: Format,
7295    pub samples: SampleCountFlags,
7296    pub load_op: AttachmentLoadOp,
7297    pub store_op: AttachmentStoreOp,
7298    pub stencil_load_op: AttachmentLoadOp,
7299    pub stencil_store_op: AttachmentStoreOp,
7300    pub initial_layout: ImageLayout,
7301    pub final_layout: ImageLayout,
7302}
7303impl AttachmentDescription {
7304    pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> {
7305        AttachmentDescriptionBuilder {
7306            inner: Self::default(),
7307            marker: ::std::marker::PhantomData,
7308        }
7309    }
7310}
7311#[repr(transparent)]
7312pub struct AttachmentDescriptionBuilder<'a> {
7313    inner: AttachmentDescription,
7314    marker: ::std::marker::PhantomData<&'a ()>,
7315}
7316impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> {
7317    type Target = AttachmentDescription;
7318    fn deref(&self) -> &Self::Target {
7319        &self.inner
7320    }
7321}
7322impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> {
7323    fn deref_mut(&mut self) -> &mut Self::Target {
7324        &mut self.inner
7325    }
7326}
7327impl<'a> AttachmentDescriptionBuilder<'a> {
7328    pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
7329        self.inner.flags = flags;
7330        self
7331    }
7332    pub fn format(mut self, format: Format) -> Self {
7333        self.inner.format = format;
7334        self
7335    }
7336    pub fn samples(mut self, samples: SampleCountFlags) -> Self {
7337        self.inner.samples = samples;
7338        self
7339    }
7340    pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
7341        self.inner.load_op = load_op;
7342        self
7343    }
7344    pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
7345        self.inner.store_op = store_op;
7346        self
7347    }
7348    pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
7349        self.inner.stencil_load_op = stencil_load_op;
7350        self
7351    }
7352    pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
7353        self.inner.stencil_store_op = stencil_store_op;
7354        self
7355    }
7356    pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
7357        self.inner.initial_layout = initial_layout;
7358        self
7359    }
7360    pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
7361        self.inner.final_layout = final_layout;
7362        self
7363    }
7364    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7365    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7366    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7367    pub fn build(self) -> AttachmentDescription {
7368        self.inner
7369    }
7370}
7371#[repr(C)]
7372#[cfg_attr(feature = "debug", derive(Debug))]
7373#[derive(Copy, Clone, Default)]
7374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference.html>"]
7375pub struct AttachmentReference {
7376    pub attachment: u32,
7377    pub layout: ImageLayout,
7378}
7379impl AttachmentReference {
7380    pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> {
7381        AttachmentReferenceBuilder {
7382            inner: Self::default(),
7383            marker: ::std::marker::PhantomData,
7384        }
7385    }
7386}
7387#[repr(transparent)]
7388pub struct AttachmentReferenceBuilder<'a> {
7389    inner: AttachmentReference,
7390    marker: ::std::marker::PhantomData<&'a ()>,
7391}
7392impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> {
7393    type Target = AttachmentReference;
7394    fn deref(&self) -> &Self::Target {
7395        &self.inner
7396    }
7397}
7398impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> {
7399    fn deref_mut(&mut self) -> &mut Self::Target {
7400        &mut self.inner
7401    }
7402}
7403impl<'a> AttachmentReferenceBuilder<'a> {
7404    pub fn attachment(mut self, attachment: u32) -> Self {
7405        self.inner.attachment = attachment;
7406        self
7407    }
7408    pub fn layout(mut self, layout: ImageLayout) -> Self {
7409        self.inner.layout = layout;
7410        self
7411    }
7412    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7413    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7414    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7415    pub fn build(self) -> AttachmentReference {
7416        self.inner
7417    }
7418}
7419#[repr(C)]
7420#[cfg_attr(feature = "debug", derive(Debug))]
7421#[derive(Copy, Clone)]
7422#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription.html>"]
7423pub struct SubpassDescription {
7424    pub flags: SubpassDescriptionFlags,
7425    pub pipeline_bind_point: PipelineBindPoint,
7426    pub input_attachment_count: u32,
7427    pub p_input_attachments: *const AttachmentReference,
7428    pub color_attachment_count: u32,
7429    pub p_color_attachments: *const AttachmentReference,
7430    pub p_resolve_attachments: *const AttachmentReference,
7431    pub p_depth_stencil_attachment: *const AttachmentReference,
7432    pub preserve_attachment_count: u32,
7433    pub p_preserve_attachments: *const u32,
7434}
7435impl ::std::default::Default for SubpassDescription {
7436    fn default() -> Self {
7437        Self {
7438            flags: SubpassDescriptionFlags::default(),
7439            pipeline_bind_point: PipelineBindPoint::default(),
7440            input_attachment_count: u32::default(),
7441            p_input_attachments: ::std::ptr::null(),
7442            color_attachment_count: u32::default(),
7443            p_color_attachments: ::std::ptr::null(),
7444            p_resolve_attachments: ::std::ptr::null(),
7445            p_depth_stencil_attachment: ::std::ptr::null(),
7446            preserve_attachment_count: u32::default(),
7447            p_preserve_attachments: ::std::ptr::null(),
7448        }
7449    }
7450}
7451impl SubpassDescription {
7452    pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> {
7453        SubpassDescriptionBuilder {
7454            inner: Self::default(),
7455            marker: ::std::marker::PhantomData,
7456        }
7457    }
7458}
7459#[repr(transparent)]
7460pub struct SubpassDescriptionBuilder<'a> {
7461    inner: SubpassDescription,
7462    marker: ::std::marker::PhantomData<&'a ()>,
7463}
7464impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> {
7465    type Target = SubpassDescription;
7466    fn deref(&self) -> &Self::Target {
7467        &self.inner
7468    }
7469}
7470impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> {
7471    fn deref_mut(&mut self) -> &mut Self::Target {
7472        &mut self.inner
7473    }
7474}
7475impl<'a> SubpassDescriptionBuilder<'a> {
7476    pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
7477        self.inner.flags = flags;
7478        self
7479    }
7480    pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
7481        self.inner.pipeline_bind_point = pipeline_bind_point;
7482        self
7483    }
7484    pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self {
7485        self.inner.input_attachment_count = input_attachments.len() as _;
7486        self.inner.p_input_attachments = input_attachments.as_ptr();
7487        self
7488    }
7489    pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self {
7490        self.inner.color_attachment_count = color_attachments.len() as _;
7491        self.inner.p_color_attachments = color_attachments.as_ptr();
7492        self
7493    }
7494    pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self {
7495        self.inner.color_attachment_count = resolve_attachments.len() as _;
7496        self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
7497        self
7498    }
7499    pub fn depth_stencil_attachment(
7500        mut self,
7501        depth_stencil_attachment: &'a AttachmentReference,
7502    ) -> Self {
7503        self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
7504        self
7505    }
7506    pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
7507        self.inner.preserve_attachment_count = preserve_attachments.len() as _;
7508        self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
7509        self
7510    }
7511    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7512    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7513    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7514    pub fn build(self) -> SubpassDescription {
7515        self.inner
7516    }
7517}
7518#[repr(C)]
7519#[cfg_attr(feature = "debug", derive(Debug))]
7520#[derive(Copy, Clone, Default)]
7521#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency.html>"]
7522pub struct SubpassDependency {
7523    pub src_subpass: u32,
7524    pub dst_subpass: u32,
7525    pub src_stage_mask: PipelineStageFlags,
7526    pub dst_stage_mask: PipelineStageFlags,
7527    pub src_access_mask: AccessFlags,
7528    pub dst_access_mask: AccessFlags,
7529    pub dependency_flags: DependencyFlags,
7530}
7531impl SubpassDependency {
7532    pub fn builder<'a>() -> SubpassDependencyBuilder<'a> {
7533        SubpassDependencyBuilder {
7534            inner: Self::default(),
7535            marker: ::std::marker::PhantomData,
7536        }
7537    }
7538}
7539#[repr(transparent)]
7540pub struct SubpassDependencyBuilder<'a> {
7541    inner: SubpassDependency,
7542    marker: ::std::marker::PhantomData<&'a ()>,
7543}
7544impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> {
7545    type Target = SubpassDependency;
7546    fn deref(&self) -> &Self::Target {
7547        &self.inner
7548    }
7549}
7550impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> {
7551    fn deref_mut(&mut self) -> &mut Self::Target {
7552        &mut self.inner
7553    }
7554}
7555impl<'a> SubpassDependencyBuilder<'a> {
7556    pub fn src_subpass(mut self, src_subpass: u32) -> Self {
7557        self.inner.src_subpass = src_subpass;
7558        self
7559    }
7560    pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
7561        self.inner.dst_subpass = dst_subpass;
7562        self
7563    }
7564    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
7565        self.inner.src_stage_mask = src_stage_mask;
7566        self
7567    }
7568    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
7569        self.inner.dst_stage_mask = dst_stage_mask;
7570        self
7571    }
7572    pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
7573        self.inner.src_access_mask = src_access_mask;
7574        self
7575    }
7576    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
7577        self.inner.dst_access_mask = dst_access_mask;
7578        self
7579    }
7580    pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
7581        self.inner.dependency_flags = dependency_flags;
7582        self
7583    }
7584    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7585    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7586    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7587    pub fn build(self) -> SubpassDependency {
7588        self.inner
7589    }
7590}
7591#[repr(C)]
7592#[cfg_attr(feature = "debug", derive(Debug))]
7593#[derive(Copy, Clone)]
7594#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo.html>"]
7595pub struct RenderPassCreateInfo {
7596    pub s_type: StructureType,
7597    pub p_next: *const c_void,
7598    pub flags: RenderPassCreateFlags,
7599    pub attachment_count: u32,
7600    pub p_attachments: *const AttachmentDescription,
7601    pub subpass_count: u32,
7602    pub p_subpasses: *const SubpassDescription,
7603    pub dependency_count: u32,
7604    pub p_dependencies: *const SubpassDependency,
7605}
7606impl ::std::default::Default for RenderPassCreateInfo {
7607    fn default() -> Self {
7608        Self {
7609            s_type: StructureType::RENDER_PASS_CREATE_INFO,
7610            p_next: ::std::ptr::null(),
7611            flags: RenderPassCreateFlags::default(),
7612            attachment_count: u32::default(),
7613            p_attachments: ::std::ptr::null(),
7614            subpass_count: u32::default(),
7615            p_subpasses: ::std::ptr::null(),
7616            dependency_count: u32::default(),
7617            p_dependencies: ::std::ptr::null(),
7618        }
7619    }
7620}
7621impl RenderPassCreateInfo {
7622    pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> {
7623        RenderPassCreateInfoBuilder {
7624            inner: Self::default(),
7625            marker: ::std::marker::PhantomData,
7626        }
7627    }
7628}
7629#[repr(transparent)]
7630pub struct RenderPassCreateInfoBuilder<'a> {
7631    inner: RenderPassCreateInfo,
7632    marker: ::std::marker::PhantomData<&'a ()>,
7633}
7634pub unsafe trait ExtendsRenderPassCreateInfo {}
7635impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> {
7636    type Target = RenderPassCreateInfo;
7637    fn deref(&self) -> &Self::Target {
7638        &self.inner
7639    }
7640}
7641impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
7642    fn deref_mut(&mut self) -> &mut Self::Target {
7643        &mut self.inner
7644    }
7645}
7646impl<'a> RenderPassCreateInfoBuilder<'a> {
7647    pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
7648        self.inner.flags = flags;
7649        self
7650    }
7651    pub fn attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self {
7652        self.inner.attachment_count = attachments.len() as _;
7653        self.inner.p_attachments = attachments.as_ptr();
7654        self
7655    }
7656    pub fn subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self {
7657        self.inner.subpass_count = subpasses.len() as _;
7658        self.inner.p_subpasses = subpasses.as_ptr();
7659        self
7660    }
7661    pub fn dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self {
7662        self.inner.dependency_count = dependencies.len() as _;
7663        self.inner.p_dependencies = dependencies.as_ptr();
7664        self
7665    }
7666    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7667    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7668    #[doc = r" valid extension structs can be pushed into the chain."]
7669    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7670    #[doc = r" chain will look like `A -> D -> B -> C`."]
7671    pub fn push_next<T: ExtendsRenderPassCreateInfo>(mut self, next: &'a mut T) -> Self {
7672        unsafe {
7673            let next_ptr = <*const T>::cast(next);
7674            let last_next = ptr_chain_iter(next).last().unwrap();
7675            (*last_next).p_next = self.inner.p_next as _;
7676            self.inner.p_next = next_ptr;
7677        }
7678        self
7679    }
7680    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7681    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7682    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7683    pub fn build(self) -> RenderPassCreateInfo {
7684        self.inner
7685    }
7686}
7687#[repr(C)]
7688#[cfg_attr(feature = "debug", derive(Debug))]
7689#[derive(Copy, Clone)]
7690#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateInfo.html>"]
7691pub struct EventCreateInfo {
7692    pub s_type: StructureType,
7693    pub p_next: *const c_void,
7694    pub flags: EventCreateFlags,
7695}
7696impl ::std::default::Default for EventCreateInfo {
7697    fn default() -> Self {
7698        Self {
7699            s_type: StructureType::EVENT_CREATE_INFO,
7700            p_next: ::std::ptr::null(),
7701            flags: EventCreateFlags::default(),
7702        }
7703    }
7704}
7705impl EventCreateInfo {
7706    pub fn builder<'a>() -> EventCreateInfoBuilder<'a> {
7707        EventCreateInfoBuilder {
7708            inner: Self::default(),
7709            marker: ::std::marker::PhantomData,
7710        }
7711    }
7712}
7713#[repr(transparent)]
7714pub struct EventCreateInfoBuilder<'a> {
7715    inner: EventCreateInfo,
7716    marker: ::std::marker::PhantomData<&'a ()>,
7717}
7718impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> {
7719    type Target = EventCreateInfo;
7720    fn deref(&self) -> &Self::Target {
7721        &self.inner
7722    }
7723}
7724impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> {
7725    fn deref_mut(&mut self) -> &mut Self::Target {
7726        &mut self.inner
7727    }
7728}
7729impl<'a> EventCreateInfoBuilder<'a> {
7730    pub fn flags(mut self, flags: EventCreateFlags) -> Self {
7731        self.inner.flags = flags;
7732        self
7733    }
7734    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7735    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7736    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7737    pub fn build(self) -> EventCreateInfo {
7738        self.inner
7739    }
7740}
7741#[repr(C)]
7742#[cfg_attr(feature = "debug", derive(Debug))]
7743#[derive(Copy, Clone)]
7744#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateInfo.html>"]
7745pub struct FenceCreateInfo {
7746    pub s_type: StructureType,
7747    pub p_next: *const c_void,
7748    pub flags: FenceCreateFlags,
7749}
7750impl ::std::default::Default for FenceCreateInfo {
7751    fn default() -> Self {
7752        Self {
7753            s_type: StructureType::FENCE_CREATE_INFO,
7754            p_next: ::std::ptr::null(),
7755            flags: FenceCreateFlags::default(),
7756        }
7757    }
7758}
7759impl FenceCreateInfo {
7760    pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> {
7761        FenceCreateInfoBuilder {
7762            inner: Self::default(),
7763            marker: ::std::marker::PhantomData,
7764        }
7765    }
7766}
7767#[repr(transparent)]
7768pub struct FenceCreateInfoBuilder<'a> {
7769    inner: FenceCreateInfo,
7770    marker: ::std::marker::PhantomData<&'a ()>,
7771}
7772pub unsafe trait ExtendsFenceCreateInfo {}
7773impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> {
7774    type Target = FenceCreateInfo;
7775    fn deref(&self) -> &Self::Target {
7776        &self.inner
7777    }
7778}
7779impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> {
7780    fn deref_mut(&mut self) -> &mut Self::Target {
7781        &mut self.inner
7782    }
7783}
7784impl<'a> FenceCreateInfoBuilder<'a> {
7785    pub fn flags(mut self, flags: FenceCreateFlags) -> Self {
7786        self.inner.flags = flags;
7787        self
7788    }
7789    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7790    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7791    #[doc = r" valid extension structs can be pushed into the chain."]
7792    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7793    #[doc = r" chain will look like `A -> D -> B -> C`."]
7794    pub fn push_next<T: ExtendsFenceCreateInfo>(mut self, next: &'a mut T) -> Self {
7795        unsafe {
7796            let next_ptr = <*const T>::cast(next);
7797            let last_next = ptr_chain_iter(next).last().unwrap();
7798            (*last_next).p_next = self.inner.p_next as _;
7799            self.inner.p_next = next_ptr;
7800        }
7801        self
7802    }
7803    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7804    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7805    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
7806    pub fn build(self) -> FenceCreateInfo {
7807        self.inner
7808    }
7809}
7810#[repr(C)]
7811#[cfg_attr(feature = "debug", derive(Debug))]
7812#[derive(Copy, Clone, Default)]
7813#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures.html>"]
7814pub struct PhysicalDeviceFeatures {
7815    pub robust_buffer_access: Bool32,
7816    pub full_draw_index_uint32: Bool32,
7817    pub image_cube_array: Bool32,
7818    pub independent_blend: Bool32,
7819    pub geometry_shader: Bool32,
7820    pub tessellation_shader: Bool32,
7821    pub sample_rate_shading: Bool32,
7822    pub dual_src_blend: Bool32,
7823    pub logic_op: Bool32,
7824    pub multi_draw_indirect: Bool32,
7825    pub draw_indirect_first_instance: Bool32,
7826    pub depth_clamp: Bool32,
7827    pub depth_bias_clamp: Bool32,
7828    pub fill_mode_non_solid: Bool32,
7829    pub depth_bounds: Bool32,
7830    pub wide_lines: Bool32,
7831    pub large_points: Bool32,
7832    pub alpha_to_one: Bool32,
7833    pub multi_viewport: Bool32,
7834    pub sampler_anisotropy: Bool32,
7835    pub texture_compression_etc2: Bool32,
7836    pub texture_compression_astc_ldr: Bool32,
7837    pub texture_compression_bc: Bool32,
7838    pub occlusion_query_precise: Bool32,
7839    pub pipeline_statistics_query: Bool32,
7840    pub vertex_pipeline_stores_and_atomics: Bool32,
7841    pub fragment_stores_and_atomics: Bool32,
7842    pub shader_tessellation_and_geometry_point_size: Bool32,
7843    pub shader_image_gather_extended: Bool32,
7844    pub shader_storage_image_extended_formats: Bool32,
7845    pub shader_storage_image_multisample: Bool32,
7846    pub shader_storage_image_read_without_format: Bool32,
7847    pub shader_storage_image_write_without_format: Bool32,
7848    pub shader_uniform_buffer_array_dynamic_indexing: Bool32,
7849    pub shader_sampled_image_array_dynamic_indexing: Bool32,
7850    pub shader_storage_buffer_array_dynamic_indexing: Bool32,
7851    pub shader_storage_image_array_dynamic_indexing: Bool32,
7852    pub shader_clip_distance: Bool32,
7853    pub shader_cull_distance: Bool32,
7854    pub shader_float64: Bool32,
7855    pub shader_int64: Bool32,
7856    pub shader_int16: Bool32,
7857    pub shader_resource_residency: Bool32,
7858    pub shader_resource_min_lod: Bool32,
7859    pub sparse_binding: Bool32,
7860    pub sparse_residency_buffer: Bool32,
7861    pub sparse_residency_image2_d: Bool32,
7862    pub sparse_residency_image3_d: Bool32,
7863    pub sparse_residency2_samples: Bool32,
7864    pub sparse_residency4_samples: Bool32,
7865    pub sparse_residency8_samples: Bool32,
7866    pub sparse_residency16_samples: Bool32,
7867    pub sparse_residency_aliased: Bool32,
7868    pub variable_multisample_rate: Bool32,
7869    pub inherited_queries: Bool32,
7870}
7871impl PhysicalDeviceFeatures {
7872    pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> {
7873        PhysicalDeviceFeaturesBuilder {
7874            inner: Self::default(),
7875            marker: ::std::marker::PhantomData,
7876        }
7877    }
7878}
7879#[repr(transparent)]
7880pub struct PhysicalDeviceFeaturesBuilder<'a> {
7881    inner: PhysicalDeviceFeatures,
7882    marker: ::std::marker::PhantomData<&'a ()>,
7883}
7884impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> {
7885    type Target = PhysicalDeviceFeatures;
7886    fn deref(&self) -> &Self::Target {
7887        &self.inner
7888    }
7889}
7890impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> {
7891    fn deref_mut(&mut self) -> &mut Self::Target {
7892        &mut self.inner
7893    }
7894}
7895impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
7896    pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self {
7897        self.inner.robust_buffer_access = robust_buffer_access.into();
7898        self
7899    }
7900    pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self {
7901        self.inner.full_draw_index_uint32 = full_draw_index_uint32.into();
7902        self
7903    }
7904    pub fn image_cube_array(mut self, image_cube_array: bool) -> Self {
7905        self.inner.image_cube_array = image_cube_array.into();
7906        self
7907    }
7908    pub fn independent_blend(mut self, independent_blend: bool) -> Self {
7909        self.inner.independent_blend = independent_blend.into();
7910        self
7911    }
7912    pub fn geometry_shader(mut self, geometry_shader: bool) -> Self {
7913        self.inner.geometry_shader = geometry_shader.into();
7914        self
7915    }
7916    pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self {
7917        self.inner.tessellation_shader = tessellation_shader.into();
7918        self
7919    }
7920    pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self {
7921        self.inner.sample_rate_shading = sample_rate_shading.into();
7922        self
7923    }
7924    pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self {
7925        self.inner.dual_src_blend = dual_src_blend.into();
7926        self
7927    }
7928    pub fn logic_op(mut self, logic_op: bool) -> Self {
7929        self.inner.logic_op = logic_op.into();
7930        self
7931    }
7932    pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self {
7933        self.inner.multi_draw_indirect = multi_draw_indirect.into();
7934        self
7935    }
7936    pub fn draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self {
7937        self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into();
7938        self
7939    }
7940    pub fn depth_clamp(mut self, depth_clamp: bool) -> Self {
7941        self.inner.depth_clamp = depth_clamp.into();
7942        self
7943    }
7944    pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self {
7945        self.inner.depth_bias_clamp = depth_bias_clamp.into();
7946        self
7947    }
7948    pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self {
7949        self.inner.fill_mode_non_solid = fill_mode_non_solid.into();
7950        self
7951    }
7952    pub fn depth_bounds(mut self, depth_bounds: bool) -> Self {
7953        self.inner.depth_bounds = depth_bounds.into();
7954        self
7955    }
7956    pub fn wide_lines(mut self, wide_lines: bool) -> Self {
7957        self.inner.wide_lines = wide_lines.into();
7958        self
7959    }
7960    pub fn large_points(mut self, large_points: bool) -> Self {
7961        self.inner.large_points = large_points.into();
7962        self
7963    }
7964    pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self {
7965        self.inner.alpha_to_one = alpha_to_one.into();
7966        self
7967    }
7968    pub fn multi_viewport(mut self, multi_viewport: bool) -> Self {
7969        self.inner.multi_viewport = multi_viewport.into();
7970        self
7971    }
7972    pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self {
7973        self.inner.sampler_anisotropy = sampler_anisotropy.into();
7974        self
7975    }
7976    pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self {
7977        self.inner.texture_compression_etc2 = texture_compression_etc2.into();
7978        self
7979    }
7980    pub fn texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self {
7981        self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into();
7982        self
7983    }
7984    pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self {
7985        self.inner.texture_compression_bc = texture_compression_bc.into();
7986        self
7987    }
7988    pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self {
7989        self.inner.occlusion_query_precise = occlusion_query_precise.into();
7990        self
7991    }
7992    pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self {
7993        self.inner.pipeline_statistics_query = pipeline_statistics_query.into();
7994        self
7995    }
7996    pub fn vertex_pipeline_stores_and_atomics(
7997        mut self,
7998        vertex_pipeline_stores_and_atomics: bool,
7999    ) -> Self {
8000        self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into();
8001        self
8002    }
8003    pub fn fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self {
8004        self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into();
8005        self
8006    }
8007    pub fn shader_tessellation_and_geometry_point_size(
8008        mut self,
8009        shader_tessellation_and_geometry_point_size: bool,
8010    ) -> Self {
8011        self.inner.shader_tessellation_and_geometry_point_size =
8012            shader_tessellation_and_geometry_point_size.into();
8013        self
8014    }
8015    pub fn shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self {
8016        self.inner.shader_image_gather_extended = shader_image_gather_extended.into();
8017        self
8018    }
8019    pub fn shader_storage_image_extended_formats(
8020        mut self,
8021        shader_storage_image_extended_formats: bool,
8022    ) -> Self {
8023        self.inner.shader_storage_image_extended_formats =
8024            shader_storage_image_extended_formats.into();
8025        self
8026    }
8027    pub fn shader_storage_image_multisample(
8028        mut self,
8029        shader_storage_image_multisample: bool,
8030    ) -> Self {
8031        self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into();
8032        self
8033    }
8034    pub fn shader_storage_image_read_without_format(
8035        mut self,
8036        shader_storage_image_read_without_format: bool,
8037    ) -> Self {
8038        self.inner.shader_storage_image_read_without_format =
8039            shader_storage_image_read_without_format.into();
8040        self
8041    }
8042    pub fn shader_storage_image_write_without_format(
8043        mut self,
8044        shader_storage_image_write_without_format: bool,
8045    ) -> Self {
8046        self.inner.shader_storage_image_write_without_format =
8047            shader_storage_image_write_without_format.into();
8048        self
8049    }
8050    pub fn shader_uniform_buffer_array_dynamic_indexing(
8051        mut self,
8052        shader_uniform_buffer_array_dynamic_indexing: bool,
8053    ) -> Self {
8054        self.inner.shader_uniform_buffer_array_dynamic_indexing =
8055            shader_uniform_buffer_array_dynamic_indexing.into();
8056        self
8057    }
8058    pub fn shader_sampled_image_array_dynamic_indexing(
8059        mut self,
8060        shader_sampled_image_array_dynamic_indexing: bool,
8061    ) -> Self {
8062        self.inner.shader_sampled_image_array_dynamic_indexing =
8063            shader_sampled_image_array_dynamic_indexing.into();
8064        self
8065    }
8066    pub fn shader_storage_buffer_array_dynamic_indexing(
8067        mut self,
8068        shader_storage_buffer_array_dynamic_indexing: bool,
8069    ) -> Self {
8070        self.inner.shader_storage_buffer_array_dynamic_indexing =
8071            shader_storage_buffer_array_dynamic_indexing.into();
8072        self
8073    }
8074    pub fn shader_storage_image_array_dynamic_indexing(
8075        mut self,
8076        shader_storage_image_array_dynamic_indexing: bool,
8077    ) -> Self {
8078        self.inner.shader_storage_image_array_dynamic_indexing =
8079            shader_storage_image_array_dynamic_indexing.into();
8080        self
8081    }
8082    pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self {
8083        self.inner.shader_clip_distance = shader_clip_distance.into();
8084        self
8085    }
8086    pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self {
8087        self.inner.shader_cull_distance = shader_cull_distance.into();
8088        self
8089    }
8090    pub fn shader_float64(mut self, shader_float64: bool) -> Self {
8091        self.inner.shader_float64 = shader_float64.into();
8092        self
8093    }
8094    pub fn shader_int64(mut self, shader_int64: bool) -> Self {
8095        self.inner.shader_int64 = shader_int64.into();
8096        self
8097    }
8098    pub fn shader_int16(mut self, shader_int16: bool) -> Self {
8099        self.inner.shader_int16 = shader_int16.into();
8100        self
8101    }
8102    pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self {
8103        self.inner.shader_resource_residency = shader_resource_residency.into();
8104        self
8105    }
8106    pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self {
8107        self.inner.shader_resource_min_lod = shader_resource_min_lod.into();
8108        self
8109    }
8110    pub fn sparse_binding(mut self, sparse_binding: bool) -> Self {
8111        self.inner.sparse_binding = sparse_binding.into();
8112        self
8113    }
8114    pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self {
8115        self.inner.sparse_residency_buffer = sparse_residency_buffer.into();
8116        self
8117    }
8118    pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self {
8119        self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into();
8120        self
8121    }
8122    pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self {
8123        self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into();
8124        self
8125    }
8126    pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self {
8127        self.inner.sparse_residency2_samples = sparse_residency2_samples.into();
8128        self
8129    }
8130    pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self {
8131        self.inner.sparse_residency4_samples = sparse_residency4_samples.into();
8132        self
8133    }
8134    pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self {
8135        self.inner.sparse_residency8_samples = sparse_residency8_samples.into();
8136        self
8137    }
8138    pub fn sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self {
8139        self.inner.sparse_residency16_samples = sparse_residency16_samples.into();
8140        self
8141    }
8142    pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self {
8143        self.inner.sparse_residency_aliased = sparse_residency_aliased.into();
8144        self
8145    }
8146    pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self {
8147        self.inner.variable_multisample_rate = variable_multisample_rate.into();
8148        self
8149    }
8150    pub fn inherited_queries(mut self, inherited_queries: bool) -> Self {
8151        self.inner.inherited_queries = inherited_queries.into();
8152        self
8153    }
8154    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8155    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8156    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
8157    pub fn build(self) -> PhysicalDeviceFeatures {
8158        self.inner
8159    }
8160}
8161#[repr(C)]
8162#[cfg_attr(feature = "debug", derive(Debug))]
8163#[derive(Copy, Clone, Default)]
8164#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseProperties.html>"]
8165pub struct PhysicalDeviceSparseProperties {
8166    pub residency_standard2_d_block_shape: Bool32,
8167    pub residency_standard2_d_multisample_block_shape: Bool32,
8168    pub residency_standard3_d_block_shape: Bool32,
8169    pub residency_aligned_mip_size: Bool32,
8170    pub residency_non_resident_strict: Bool32,
8171}
8172impl PhysicalDeviceSparseProperties {
8173    pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8174        PhysicalDeviceSparsePropertiesBuilder {
8175            inner: Self::default(),
8176            marker: ::std::marker::PhantomData,
8177        }
8178    }
8179}
8180#[repr(transparent)]
8181pub struct PhysicalDeviceSparsePropertiesBuilder<'a> {
8182    inner: PhysicalDeviceSparseProperties,
8183    marker: ::std::marker::PhantomData<&'a ()>,
8184}
8185impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> {
8186    type Target = PhysicalDeviceSparseProperties;
8187    fn deref(&self) -> &Self::Target {
8188        &self.inner
8189    }
8190}
8191impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> {
8192    fn deref_mut(&mut self) -> &mut Self::Target {
8193        &mut self.inner
8194    }
8195}
8196impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
8197    pub fn residency_standard2_d_block_shape(
8198        mut self,
8199        residency_standard2_d_block_shape: bool,
8200    ) -> Self {
8201        self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into();
8202        self
8203    }
8204    pub fn residency_standard2_d_multisample_block_shape(
8205        mut self,
8206        residency_standard2_d_multisample_block_shape: bool,
8207    ) -> Self {
8208        self.inner.residency_standard2_d_multisample_block_shape =
8209            residency_standard2_d_multisample_block_shape.into();
8210        self
8211    }
8212    pub fn residency_standard3_d_block_shape(
8213        mut self,
8214        residency_standard3_d_block_shape: bool,
8215    ) -> Self {
8216        self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into();
8217        self
8218    }
8219    pub fn residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self {
8220        self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into();
8221        self
8222    }
8223    pub fn residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self {
8224        self.inner.residency_non_resident_strict = residency_non_resident_strict.into();
8225        self
8226    }
8227    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8228    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8229    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
8230    pub fn build(self) -> PhysicalDeviceSparseProperties {
8231        self.inner
8232    }
8233}
8234#[repr(C)]
8235#[cfg_attr(feature = "debug", derive(Debug))]
8236#[derive(Copy, Clone)]
8237#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLimits.html>"]
8238pub struct PhysicalDeviceLimits {
8239    pub max_image_dimension1_d: u32,
8240    pub max_image_dimension2_d: u32,
8241    pub max_image_dimension3_d: u32,
8242    pub max_image_dimension_cube: u32,
8243    pub max_image_array_layers: u32,
8244    pub max_texel_buffer_elements: u32,
8245    pub max_uniform_buffer_range: u32,
8246    pub max_storage_buffer_range: u32,
8247    pub max_push_constants_size: u32,
8248    pub max_memory_allocation_count: u32,
8249    pub max_sampler_allocation_count: u32,
8250    pub buffer_image_granularity: DeviceSize,
8251    pub sparse_address_space_size: DeviceSize,
8252    pub max_bound_descriptor_sets: u32,
8253    pub max_per_stage_descriptor_samplers: u32,
8254    pub max_per_stage_descriptor_uniform_buffers: u32,
8255    pub max_per_stage_descriptor_storage_buffers: u32,
8256    pub max_per_stage_descriptor_sampled_images: u32,
8257    pub max_per_stage_descriptor_storage_images: u32,
8258    pub max_per_stage_descriptor_input_attachments: u32,
8259    pub max_per_stage_resources: u32,
8260    pub max_descriptor_set_samplers: u32,
8261    pub max_descriptor_set_uniform_buffers: u32,
8262    pub max_descriptor_set_uniform_buffers_dynamic: u32,
8263    pub max_descriptor_set_storage_buffers: u32,
8264    pub max_descriptor_set_storage_buffers_dynamic: u32,
8265    pub max_descriptor_set_sampled_images: u32,
8266    pub max_descriptor_set_storage_images: u32,
8267    pub max_descriptor_set_input_attachments: u32,
8268    pub max_vertex_input_attributes: u32,
8269    pub max_vertex_input_bindings: u32,
8270    pub max_vertex_input_attribute_offset: u32,
8271    pub max_vertex_input_binding_stride: u32,
8272    pub max_vertex_output_components: u32,
8273    pub max_tessellation_generation_level: u32,
8274    pub max_tessellation_patch_size: u32,
8275    pub max_tessellation_control_per_vertex_input_components: u32,
8276    pub max_tessellation_control_per_vertex_output_components: u32,
8277    pub max_tessellation_control_per_patch_output_components: u32,
8278    pub max_tessellation_control_total_output_components: u32,
8279    pub max_tessellation_evaluation_input_components: u32,
8280    pub max_tessellation_evaluation_output_components: u32,
8281    pub max_geometry_shader_invocations: u32,
8282    pub max_geometry_input_components: u32,
8283    pub max_geometry_output_components: u32,
8284    pub max_geometry_output_vertices: u32,
8285    pub max_geometry_total_output_components: u32,
8286    pub max_fragment_input_components: u32,
8287    pub max_fragment_output_attachments: u32,
8288    pub max_fragment_dual_src_attachments: u32,
8289    pub max_fragment_combined_output_resources: u32,
8290    pub max_compute_shared_memory_size: u32,
8291    pub max_compute_work_group_count: [u32; 3],
8292    pub max_compute_work_group_invocations: u32,
8293    pub max_compute_work_group_size: [u32; 3],
8294    pub sub_pixel_precision_bits: u32,
8295    pub sub_texel_precision_bits: u32,
8296    pub mipmap_precision_bits: u32,
8297    pub max_draw_indexed_index_value: u32,
8298    pub max_draw_indirect_count: u32,
8299    pub max_sampler_lod_bias: f32,
8300    pub max_sampler_anisotropy: f32,
8301    pub max_viewports: u32,
8302    pub max_viewport_dimensions: [u32; 2],
8303    pub viewport_bounds_range: [f32; 2],
8304    pub viewport_sub_pixel_bits: u32,
8305    pub min_memory_map_alignment: usize,
8306    pub min_texel_buffer_offset_alignment: DeviceSize,
8307    pub min_uniform_buffer_offset_alignment: DeviceSize,
8308    pub min_storage_buffer_offset_alignment: DeviceSize,
8309    pub min_texel_offset: i32,
8310    pub max_texel_offset: u32,
8311    pub min_texel_gather_offset: i32,
8312    pub max_texel_gather_offset: u32,
8313    pub min_interpolation_offset: f32,
8314    pub max_interpolation_offset: f32,
8315    pub sub_pixel_interpolation_offset_bits: u32,
8316    pub max_framebuffer_width: u32,
8317    pub max_framebuffer_height: u32,
8318    pub max_framebuffer_layers: u32,
8319    pub framebuffer_color_sample_counts: SampleCountFlags,
8320    pub framebuffer_depth_sample_counts: SampleCountFlags,
8321    pub framebuffer_stencil_sample_counts: SampleCountFlags,
8322    pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
8323    pub max_color_attachments: u32,
8324    pub sampled_image_color_sample_counts: SampleCountFlags,
8325    pub sampled_image_integer_sample_counts: SampleCountFlags,
8326    pub sampled_image_depth_sample_counts: SampleCountFlags,
8327    pub sampled_image_stencil_sample_counts: SampleCountFlags,
8328    pub storage_image_sample_counts: SampleCountFlags,
8329    pub max_sample_mask_words: u32,
8330    pub timestamp_compute_and_graphics: Bool32,
8331    pub timestamp_period: f32,
8332    pub max_clip_distances: u32,
8333    pub max_cull_distances: u32,
8334    pub max_combined_clip_and_cull_distances: u32,
8335    pub discrete_queue_priorities: u32,
8336    pub point_size_range: [f32; 2],
8337    pub line_width_range: [f32; 2],
8338    pub point_size_granularity: f32,
8339    pub line_width_granularity: f32,
8340    pub strict_lines: Bool32,
8341    pub standard_sample_locations: Bool32,
8342    pub optimal_buffer_copy_offset_alignment: DeviceSize,
8343    pub optimal_buffer_copy_row_pitch_alignment: DeviceSize,
8344    pub non_coherent_atom_size: DeviceSize,
8345}
8346impl ::std::default::Default for PhysicalDeviceLimits {
8347    fn default() -> Self {
8348        Self {
8349            max_image_dimension1_d: u32::default(),
8350            max_image_dimension2_d: u32::default(),
8351            max_image_dimension3_d: u32::default(),
8352            max_image_dimension_cube: u32::default(),
8353            max_image_array_layers: u32::default(),
8354            max_texel_buffer_elements: u32::default(),
8355            max_uniform_buffer_range: u32::default(),
8356            max_storage_buffer_range: u32::default(),
8357            max_push_constants_size: u32::default(),
8358            max_memory_allocation_count: u32::default(),
8359            max_sampler_allocation_count: u32::default(),
8360            buffer_image_granularity: DeviceSize::default(),
8361            sparse_address_space_size: DeviceSize::default(),
8362            max_bound_descriptor_sets: u32::default(),
8363            max_per_stage_descriptor_samplers: u32::default(),
8364            max_per_stage_descriptor_uniform_buffers: u32::default(),
8365            max_per_stage_descriptor_storage_buffers: u32::default(),
8366            max_per_stage_descriptor_sampled_images: u32::default(),
8367            max_per_stage_descriptor_storage_images: u32::default(),
8368            max_per_stage_descriptor_input_attachments: u32::default(),
8369            max_per_stage_resources: u32::default(),
8370            max_descriptor_set_samplers: u32::default(),
8371            max_descriptor_set_uniform_buffers: u32::default(),
8372            max_descriptor_set_uniform_buffers_dynamic: u32::default(),
8373            max_descriptor_set_storage_buffers: u32::default(),
8374            max_descriptor_set_storage_buffers_dynamic: u32::default(),
8375            max_descriptor_set_sampled_images: u32::default(),
8376            max_descriptor_set_storage_images: u32::default(),
8377            max_descriptor_set_input_attachments: u32::default(),
8378            max_vertex_input_attributes: u32::default(),
8379            max_vertex_input_bindings: u32::default(),
8380            max_vertex_input_attribute_offset: u32::default(),
8381            max_vertex_input_binding_stride: u32::default(),
8382            max_vertex_output_components: u32::default(),
8383            max_tessellation_generation_level: u32::default(),
8384            max_tessellation_patch_size: u32::default(),
8385            max_tessellation_control_per_vertex_input_components: u32::default(),
8386            max_tessellation_control_per_vertex_output_components: u32::default(),
8387            max_tessellation_control_per_patch_output_components: u32::default(),
8388            max_tessellation_control_total_output_components: u32::default(),
8389            max_tessellation_evaluation_input_components: u32::default(),
8390            max_tessellation_evaluation_output_components: u32::default(),
8391            max_geometry_shader_invocations: u32::default(),
8392            max_geometry_input_components: u32::default(),
8393            max_geometry_output_components: u32::default(),
8394            max_geometry_output_vertices: u32::default(),
8395            max_geometry_total_output_components: u32::default(),
8396            max_fragment_input_components: u32::default(),
8397            max_fragment_output_attachments: u32::default(),
8398            max_fragment_dual_src_attachments: u32::default(),
8399            max_fragment_combined_output_resources: u32::default(),
8400            max_compute_shared_memory_size: u32::default(),
8401            max_compute_work_group_count: unsafe { ::std::mem::zeroed() },
8402            max_compute_work_group_invocations: u32::default(),
8403            max_compute_work_group_size: unsafe { ::std::mem::zeroed() },
8404            sub_pixel_precision_bits: u32::default(),
8405            sub_texel_precision_bits: u32::default(),
8406            mipmap_precision_bits: u32::default(),
8407            max_draw_indexed_index_value: u32::default(),
8408            max_draw_indirect_count: u32::default(),
8409            max_sampler_lod_bias: f32::default(),
8410            max_sampler_anisotropy: f32::default(),
8411            max_viewports: u32::default(),
8412            max_viewport_dimensions: unsafe { ::std::mem::zeroed() },
8413            viewport_bounds_range: unsafe { ::std::mem::zeroed() },
8414            viewport_sub_pixel_bits: u32::default(),
8415            min_memory_map_alignment: usize::default(),
8416            min_texel_buffer_offset_alignment: DeviceSize::default(),
8417            min_uniform_buffer_offset_alignment: DeviceSize::default(),
8418            min_storage_buffer_offset_alignment: DeviceSize::default(),
8419            min_texel_offset: i32::default(),
8420            max_texel_offset: u32::default(),
8421            min_texel_gather_offset: i32::default(),
8422            max_texel_gather_offset: u32::default(),
8423            min_interpolation_offset: f32::default(),
8424            max_interpolation_offset: f32::default(),
8425            sub_pixel_interpolation_offset_bits: u32::default(),
8426            max_framebuffer_width: u32::default(),
8427            max_framebuffer_height: u32::default(),
8428            max_framebuffer_layers: u32::default(),
8429            framebuffer_color_sample_counts: SampleCountFlags::default(),
8430            framebuffer_depth_sample_counts: SampleCountFlags::default(),
8431            framebuffer_stencil_sample_counts: SampleCountFlags::default(),
8432            framebuffer_no_attachments_sample_counts: SampleCountFlags::default(),
8433            max_color_attachments: u32::default(),
8434            sampled_image_color_sample_counts: SampleCountFlags::default(),
8435            sampled_image_integer_sample_counts: SampleCountFlags::default(),
8436            sampled_image_depth_sample_counts: SampleCountFlags::default(),
8437            sampled_image_stencil_sample_counts: SampleCountFlags::default(),
8438            storage_image_sample_counts: SampleCountFlags::default(),
8439            max_sample_mask_words: u32::default(),
8440            timestamp_compute_and_graphics: Bool32::default(),
8441            timestamp_period: f32::default(),
8442            max_clip_distances: u32::default(),
8443            max_cull_distances: u32::default(),
8444            max_combined_clip_and_cull_distances: u32::default(),
8445            discrete_queue_priorities: u32::default(),
8446            point_size_range: unsafe { ::std::mem::zeroed() },
8447            line_width_range: unsafe { ::std::mem::zeroed() },
8448            point_size_granularity: f32::default(),
8449            line_width_granularity: f32::default(),
8450            strict_lines: Bool32::default(),
8451            standard_sample_locations: Bool32::default(),
8452            optimal_buffer_copy_offset_alignment: DeviceSize::default(),
8453            optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(),
8454            non_coherent_atom_size: DeviceSize::default(),
8455        }
8456    }
8457}
8458impl PhysicalDeviceLimits {
8459    pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> {
8460        PhysicalDeviceLimitsBuilder {
8461            inner: Self::default(),
8462            marker: ::std::marker::PhantomData,
8463        }
8464    }
8465}
8466#[repr(transparent)]
8467pub struct PhysicalDeviceLimitsBuilder<'a> {
8468    inner: PhysicalDeviceLimits,
8469    marker: ::std::marker::PhantomData<&'a ()>,
8470}
8471impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> {
8472    type Target = PhysicalDeviceLimits;
8473    fn deref(&self) -> &Self::Target {
8474        &self.inner
8475    }
8476}
8477impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> {
8478    fn deref_mut(&mut self) -> &mut Self::Target {
8479        &mut self.inner
8480    }
8481}
8482impl<'a> PhysicalDeviceLimitsBuilder<'a> {
8483    pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self {
8484        self.inner.max_image_dimension1_d = max_image_dimension1_d;
8485        self
8486    }
8487    pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self {
8488        self.inner.max_image_dimension2_d = max_image_dimension2_d;
8489        self
8490    }
8491    pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self {
8492        self.inner.max_image_dimension3_d = max_image_dimension3_d;
8493        self
8494    }
8495    pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self {
8496        self.inner.max_image_dimension_cube = max_image_dimension_cube;
8497        self
8498    }
8499    pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
8500        self.inner.max_image_array_layers = max_image_array_layers;
8501        self
8502    }
8503    pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self {
8504        self.inner.max_texel_buffer_elements = max_texel_buffer_elements;
8505        self
8506    }
8507    pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self {
8508        self.inner.max_uniform_buffer_range = max_uniform_buffer_range;
8509        self
8510    }
8511    pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self {
8512        self.inner.max_storage_buffer_range = max_storage_buffer_range;
8513        self
8514    }
8515    pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self {
8516        self.inner.max_push_constants_size = max_push_constants_size;
8517        self
8518    }
8519    pub fn max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self {
8520        self.inner.max_memory_allocation_count = max_memory_allocation_count;
8521        self
8522    }
8523    pub fn max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self {
8524        self.inner.max_sampler_allocation_count = max_sampler_allocation_count;
8525        self
8526    }
8527    pub fn buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self {
8528        self.inner.buffer_image_granularity = buffer_image_granularity;
8529        self
8530    }
8531    pub fn sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self {
8532        self.inner.sparse_address_space_size = sparse_address_space_size;
8533        self
8534    }
8535    pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self {
8536        self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets;
8537        self
8538    }
8539    pub fn max_per_stage_descriptor_samplers(
8540        mut self,
8541        max_per_stage_descriptor_samplers: u32,
8542    ) -> Self {
8543        self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers;
8544        self
8545    }
8546    pub fn max_per_stage_descriptor_uniform_buffers(
8547        mut self,
8548        max_per_stage_descriptor_uniform_buffers: u32,
8549    ) -> Self {
8550        self.inner.max_per_stage_descriptor_uniform_buffers =
8551            max_per_stage_descriptor_uniform_buffers;
8552        self
8553    }
8554    pub fn max_per_stage_descriptor_storage_buffers(
8555        mut self,
8556        max_per_stage_descriptor_storage_buffers: u32,
8557    ) -> Self {
8558        self.inner.max_per_stage_descriptor_storage_buffers =
8559            max_per_stage_descriptor_storage_buffers;
8560        self
8561    }
8562    pub fn max_per_stage_descriptor_sampled_images(
8563        mut self,
8564        max_per_stage_descriptor_sampled_images: u32,
8565    ) -> Self {
8566        self.inner.max_per_stage_descriptor_sampled_images =
8567            max_per_stage_descriptor_sampled_images;
8568        self
8569    }
8570    pub fn max_per_stage_descriptor_storage_images(
8571        mut self,
8572        max_per_stage_descriptor_storage_images: u32,
8573    ) -> Self {
8574        self.inner.max_per_stage_descriptor_storage_images =
8575            max_per_stage_descriptor_storage_images;
8576        self
8577    }
8578    pub fn max_per_stage_descriptor_input_attachments(
8579        mut self,
8580        max_per_stage_descriptor_input_attachments: u32,
8581    ) -> Self {
8582        self.inner.max_per_stage_descriptor_input_attachments =
8583            max_per_stage_descriptor_input_attachments;
8584        self
8585    }
8586    pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self {
8587        self.inner.max_per_stage_resources = max_per_stage_resources;
8588        self
8589    }
8590    pub fn max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self {
8591        self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers;
8592        self
8593    }
8594    pub fn max_descriptor_set_uniform_buffers(
8595        mut self,
8596        max_descriptor_set_uniform_buffers: u32,
8597    ) -> Self {
8598        self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers;
8599        self
8600    }
8601    pub fn max_descriptor_set_uniform_buffers_dynamic(
8602        mut self,
8603        max_descriptor_set_uniform_buffers_dynamic: u32,
8604    ) -> Self {
8605        self.inner.max_descriptor_set_uniform_buffers_dynamic =
8606            max_descriptor_set_uniform_buffers_dynamic;
8607        self
8608    }
8609    pub fn max_descriptor_set_storage_buffers(
8610        mut self,
8611        max_descriptor_set_storage_buffers: u32,
8612    ) -> Self {
8613        self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers;
8614        self
8615    }
8616    pub fn max_descriptor_set_storage_buffers_dynamic(
8617        mut self,
8618        max_descriptor_set_storage_buffers_dynamic: u32,
8619    ) -> Self {
8620        self.inner.max_descriptor_set_storage_buffers_dynamic =
8621            max_descriptor_set_storage_buffers_dynamic;
8622        self
8623    }
8624    pub fn max_descriptor_set_sampled_images(
8625        mut self,
8626        max_descriptor_set_sampled_images: u32,
8627    ) -> Self {
8628        self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images;
8629        self
8630    }
8631    pub fn max_descriptor_set_storage_images(
8632        mut self,
8633        max_descriptor_set_storage_images: u32,
8634    ) -> Self {
8635        self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images;
8636        self
8637    }
8638    pub fn max_descriptor_set_input_attachments(
8639        mut self,
8640        max_descriptor_set_input_attachments: u32,
8641    ) -> Self {
8642        self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments;
8643        self
8644    }
8645    pub fn max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self {
8646        self.inner.max_vertex_input_attributes = max_vertex_input_attributes;
8647        self
8648    }
8649    pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self {
8650        self.inner.max_vertex_input_bindings = max_vertex_input_bindings;
8651        self
8652    }
8653    pub fn max_vertex_input_attribute_offset(
8654        mut self,
8655        max_vertex_input_attribute_offset: u32,
8656    ) -> Self {
8657        self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset;
8658        self
8659    }
8660    pub fn max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self {
8661        self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride;
8662        self
8663    }
8664    pub fn max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self {
8665        self.inner.max_vertex_output_components = max_vertex_output_components;
8666        self
8667    }
8668    pub fn max_tessellation_generation_level(
8669        mut self,
8670        max_tessellation_generation_level: u32,
8671    ) -> Self {
8672        self.inner.max_tessellation_generation_level = max_tessellation_generation_level;
8673        self
8674    }
8675    pub fn max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self {
8676        self.inner.max_tessellation_patch_size = max_tessellation_patch_size;
8677        self
8678    }
8679    pub fn max_tessellation_control_per_vertex_input_components(
8680        mut self,
8681        max_tessellation_control_per_vertex_input_components: u32,
8682    ) -> Self {
8683        self.inner
8684            .max_tessellation_control_per_vertex_input_components =
8685            max_tessellation_control_per_vertex_input_components;
8686        self
8687    }
8688    pub fn max_tessellation_control_per_vertex_output_components(
8689        mut self,
8690        max_tessellation_control_per_vertex_output_components: u32,
8691    ) -> Self {
8692        self.inner
8693            .max_tessellation_control_per_vertex_output_components =
8694            max_tessellation_control_per_vertex_output_components;
8695        self
8696    }
8697    pub fn max_tessellation_control_per_patch_output_components(
8698        mut self,
8699        max_tessellation_control_per_patch_output_components: u32,
8700    ) -> Self {
8701        self.inner
8702            .max_tessellation_control_per_patch_output_components =
8703            max_tessellation_control_per_patch_output_components;
8704        self
8705    }
8706    pub fn max_tessellation_control_total_output_components(
8707        mut self,
8708        max_tessellation_control_total_output_components: u32,
8709    ) -> Self {
8710        self.inner.max_tessellation_control_total_output_components =
8711            max_tessellation_control_total_output_components;
8712        self
8713    }
8714    pub fn max_tessellation_evaluation_input_components(
8715        mut self,
8716        max_tessellation_evaluation_input_components: u32,
8717    ) -> Self {
8718        self.inner.max_tessellation_evaluation_input_components =
8719            max_tessellation_evaluation_input_components;
8720        self
8721    }
8722    pub fn max_tessellation_evaluation_output_components(
8723        mut self,
8724        max_tessellation_evaluation_output_components: u32,
8725    ) -> Self {
8726        self.inner.max_tessellation_evaluation_output_components =
8727            max_tessellation_evaluation_output_components;
8728        self
8729    }
8730    pub fn max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self {
8731        self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations;
8732        self
8733    }
8734    pub fn max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self {
8735        self.inner.max_geometry_input_components = max_geometry_input_components;
8736        self
8737    }
8738    pub fn max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self {
8739        self.inner.max_geometry_output_components = max_geometry_output_components;
8740        self
8741    }
8742    pub fn max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self {
8743        self.inner.max_geometry_output_vertices = max_geometry_output_vertices;
8744        self
8745    }
8746    pub fn max_geometry_total_output_components(
8747        mut self,
8748        max_geometry_total_output_components: u32,
8749    ) -> Self {
8750        self.inner.max_geometry_total_output_components = max_geometry_total_output_components;
8751        self
8752    }
8753    pub fn max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self {
8754        self.inner.max_fragment_input_components = max_fragment_input_components;
8755        self
8756    }
8757    pub fn max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self {
8758        self.inner.max_fragment_output_attachments = max_fragment_output_attachments;
8759        self
8760    }
8761    pub fn max_fragment_dual_src_attachments(
8762        mut self,
8763        max_fragment_dual_src_attachments: u32,
8764    ) -> Self {
8765        self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments;
8766        self
8767    }
8768    pub fn max_fragment_combined_output_resources(
8769        mut self,
8770        max_fragment_combined_output_resources: u32,
8771    ) -> Self {
8772        self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources;
8773        self
8774    }
8775    pub fn max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self {
8776        self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size;
8777        self
8778    }
8779    pub fn max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self {
8780        self.inner.max_compute_work_group_count = max_compute_work_group_count;
8781        self
8782    }
8783    pub fn max_compute_work_group_invocations(
8784        mut self,
8785        max_compute_work_group_invocations: u32,
8786    ) -> Self {
8787        self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations;
8788        self
8789    }
8790    pub fn max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self {
8791        self.inner.max_compute_work_group_size = max_compute_work_group_size;
8792        self
8793    }
8794    pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self {
8795        self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits;
8796        self
8797    }
8798    pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self {
8799        self.inner.sub_texel_precision_bits = sub_texel_precision_bits;
8800        self
8801    }
8802    pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self {
8803        self.inner.mipmap_precision_bits = mipmap_precision_bits;
8804        self
8805    }
8806    pub fn max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self {
8807        self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value;
8808        self
8809    }
8810    pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self {
8811        self.inner.max_draw_indirect_count = max_draw_indirect_count;
8812        self
8813    }
8814    pub fn max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self {
8815        self.inner.max_sampler_lod_bias = max_sampler_lod_bias;
8816        self
8817    }
8818    pub fn max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self {
8819        self.inner.max_sampler_anisotropy = max_sampler_anisotropy;
8820        self
8821    }
8822    pub fn max_viewports(mut self, max_viewports: u32) -> Self {
8823        self.inner.max_viewports = max_viewports;
8824        self
8825    }
8826    pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self {
8827        self.inner.max_viewport_dimensions = max_viewport_dimensions;
8828        self
8829    }
8830    pub fn viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self {
8831        self.inner.viewport_bounds_range = viewport_bounds_range;
8832        self
8833    }
8834    pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self {
8835        self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits;
8836        self
8837    }
8838    pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self {
8839        self.inner.min_memory_map_alignment = min_memory_map_alignment;
8840        self
8841    }
8842    pub fn min_texel_buffer_offset_alignment(
8843        mut self,
8844        min_texel_buffer_offset_alignment: DeviceSize,
8845    ) -> Self {
8846        self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment;
8847        self
8848    }
8849    pub fn min_uniform_buffer_offset_alignment(
8850        mut self,
8851        min_uniform_buffer_offset_alignment: DeviceSize,
8852    ) -> Self {
8853        self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment;
8854        self
8855    }
8856    pub fn min_storage_buffer_offset_alignment(
8857        mut self,
8858        min_storage_buffer_offset_alignment: DeviceSize,
8859    ) -> Self {
8860        self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment;
8861        self
8862    }
8863    pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self {
8864        self.inner.min_texel_offset = min_texel_offset;
8865        self
8866    }
8867    pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self {
8868        self.inner.max_texel_offset = max_texel_offset;
8869        self
8870    }
8871    pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self {
8872        self.inner.min_texel_gather_offset = min_texel_gather_offset;
8873        self
8874    }
8875    pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self {
8876        self.inner.max_texel_gather_offset = max_texel_gather_offset;
8877        self
8878    }
8879    pub fn min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self {
8880        self.inner.min_interpolation_offset = min_interpolation_offset;
8881        self
8882    }
8883    pub fn max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self {
8884        self.inner.max_interpolation_offset = max_interpolation_offset;
8885        self
8886    }
8887    pub fn sub_pixel_interpolation_offset_bits(
8888        mut self,
8889        sub_pixel_interpolation_offset_bits: u32,
8890    ) -> Self {
8891        self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits;
8892        self
8893    }
8894    pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self {
8895        self.inner.max_framebuffer_width = max_framebuffer_width;
8896        self
8897    }
8898    pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self {
8899        self.inner.max_framebuffer_height = max_framebuffer_height;
8900        self
8901    }
8902    pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self {
8903        self.inner.max_framebuffer_layers = max_framebuffer_layers;
8904        self
8905    }
8906    pub fn framebuffer_color_sample_counts(
8907        mut self,
8908        framebuffer_color_sample_counts: SampleCountFlags,
8909    ) -> Self {
8910        self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts;
8911        self
8912    }
8913    pub fn framebuffer_depth_sample_counts(
8914        mut self,
8915        framebuffer_depth_sample_counts: SampleCountFlags,
8916    ) -> Self {
8917        self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts;
8918        self
8919    }
8920    pub fn framebuffer_stencil_sample_counts(
8921        mut self,
8922        framebuffer_stencil_sample_counts: SampleCountFlags,
8923    ) -> Self {
8924        self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts;
8925        self
8926    }
8927    pub fn framebuffer_no_attachments_sample_counts(
8928        mut self,
8929        framebuffer_no_attachments_sample_counts: SampleCountFlags,
8930    ) -> Self {
8931        self.inner.framebuffer_no_attachments_sample_counts =
8932            framebuffer_no_attachments_sample_counts;
8933        self
8934    }
8935    pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self {
8936        self.inner.max_color_attachments = max_color_attachments;
8937        self
8938    }
8939    pub fn sampled_image_color_sample_counts(
8940        mut self,
8941        sampled_image_color_sample_counts: SampleCountFlags,
8942    ) -> Self {
8943        self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts;
8944        self
8945    }
8946    pub fn sampled_image_integer_sample_counts(
8947        mut self,
8948        sampled_image_integer_sample_counts: SampleCountFlags,
8949    ) -> Self {
8950        self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts;
8951        self
8952    }
8953    pub fn sampled_image_depth_sample_counts(
8954        mut self,
8955        sampled_image_depth_sample_counts: SampleCountFlags,
8956    ) -> Self {
8957        self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts;
8958        self
8959    }
8960    pub fn sampled_image_stencil_sample_counts(
8961        mut self,
8962        sampled_image_stencil_sample_counts: SampleCountFlags,
8963    ) -> Self {
8964        self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts;
8965        self
8966    }
8967    pub fn storage_image_sample_counts(
8968        mut self,
8969        storage_image_sample_counts: SampleCountFlags,
8970    ) -> Self {
8971        self.inner.storage_image_sample_counts = storage_image_sample_counts;
8972        self
8973    }
8974    pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self {
8975        self.inner.max_sample_mask_words = max_sample_mask_words;
8976        self
8977    }
8978    pub fn timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self {
8979        self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into();
8980        self
8981    }
8982    pub fn timestamp_period(mut self, timestamp_period: f32) -> Self {
8983        self.inner.timestamp_period = timestamp_period;
8984        self
8985    }
8986    pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self {
8987        self.inner.max_clip_distances = max_clip_distances;
8988        self
8989    }
8990    pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self {
8991        self.inner.max_cull_distances = max_cull_distances;
8992        self
8993    }
8994    pub fn max_combined_clip_and_cull_distances(
8995        mut self,
8996        max_combined_clip_and_cull_distances: u32,
8997    ) -> Self {
8998        self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances;
8999        self
9000    }
9001    pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self {
9002        self.inner.discrete_queue_priorities = discrete_queue_priorities;
9003        self
9004    }
9005    pub fn point_size_range(mut self, point_size_range: [f32; 2]) -> Self {
9006        self.inner.point_size_range = point_size_range;
9007        self
9008    }
9009    pub fn line_width_range(mut self, line_width_range: [f32; 2]) -> Self {
9010        self.inner.line_width_range = line_width_range;
9011        self
9012    }
9013    pub fn point_size_granularity(mut self, point_size_granularity: f32) -> Self {
9014        self.inner.point_size_granularity = point_size_granularity;
9015        self
9016    }
9017    pub fn line_width_granularity(mut self, line_width_granularity: f32) -> Self {
9018        self.inner.line_width_granularity = line_width_granularity;
9019        self
9020    }
9021    pub fn strict_lines(mut self, strict_lines: bool) -> Self {
9022        self.inner.strict_lines = strict_lines.into();
9023        self
9024    }
9025    pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self {
9026        self.inner.standard_sample_locations = standard_sample_locations.into();
9027        self
9028    }
9029    pub fn optimal_buffer_copy_offset_alignment(
9030        mut self,
9031        optimal_buffer_copy_offset_alignment: DeviceSize,
9032    ) -> Self {
9033        self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment;
9034        self
9035    }
9036    pub fn optimal_buffer_copy_row_pitch_alignment(
9037        mut self,
9038        optimal_buffer_copy_row_pitch_alignment: DeviceSize,
9039    ) -> Self {
9040        self.inner.optimal_buffer_copy_row_pitch_alignment =
9041            optimal_buffer_copy_row_pitch_alignment;
9042        self
9043    }
9044    pub fn non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self {
9045        self.inner.non_coherent_atom_size = non_coherent_atom_size;
9046        self
9047    }
9048    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9049    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9050    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9051    pub fn build(self) -> PhysicalDeviceLimits {
9052        self.inner
9053    }
9054}
9055#[repr(C)]
9056#[cfg_attr(feature = "debug", derive(Debug))]
9057#[derive(Copy, Clone)]
9058#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateInfo.html>"]
9059pub struct SemaphoreCreateInfo {
9060    pub s_type: StructureType,
9061    pub p_next: *const c_void,
9062    pub flags: SemaphoreCreateFlags,
9063}
9064impl ::std::default::Default for SemaphoreCreateInfo {
9065    fn default() -> Self {
9066        Self {
9067            s_type: StructureType::SEMAPHORE_CREATE_INFO,
9068            p_next: ::std::ptr::null(),
9069            flags: SemaphoreCreateFlags::default(),
9070        }
9071    }
9072}
9073impl SemaphoreCreateInfo {
9074    pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> {
9075        SemaphoreCreateInfoBuilder {
9076            inner: Self::default(),
9077            marker: ::std::marker::PhantomData,
9078        }
9079    }
9080}
9081#[repr(transparent)]
9082pub struct SemaphoreCreateInfoBuilder<'a> {
9083    inner: SemaphoreCreateInfo,
9084    marker: ::std::marker::PhantomData<&'a ()>,
9085}
9086pub unsafe trait ExtendsSemaphoreCreateInfo {}
9087impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> {
9088    type Target = SemaphoreCreateInfo;
9089    fn deref(&self) -> &Self::Target {
9090        &self.inner
9091    }
9092}
9093impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
9094    fn deref_mut(&mut self) -> &mut Self::Target {
9095        &mut self.inner
9096    }
9097}
9098impl<'a> SemaphoreCreateInfoBuilder<'a> {
9099    pub fn flags(mut self, flags: SemaphoreCreateFlags) -> Self {
9100        self.inner.flags = flags;
9101        self
9102    }
9103    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9104    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9105    #[doc = r" valid extension structs can be pushed into the chain."]
9106    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9107    #[doc = r" chain will look like `A -> D -> B -> C`."]
9108    pub fn push_next<T: ExtendsSemaphoreCreateInfo>(mut self, next: &'a mut T) -> Self {
9109        unsafe {
9110            let next_ptr = <*const T>::cast(next);
9111            let last_next = ptr_chain_iter(next).last().unwrap();
9112            (*last_next).p_next = self.inner.p_next as _;
9113            self.inner.p_next = next_ptr;
9114        }
9115        self
9116    }
9117    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9118    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9119    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9120    pub fn build(self) -> SemaphoreCreateInfo {
9121        self.inner
9122    }
9123}
9124#[repr(C)]
9125#[cfg_attr(feature = "debug", derive(Debug))]
9126#[derive(Copy, Clone)]
9127#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateInfo.html>"]
9128pub struct QueryPoolCreateInfo {
9129    pub s_type: StructureType,
9130    pub p_next: *const c_void,
9131    pub flags: QueryPoolCreateFlags,
9132    pub query_type: QueryType,
9133    pub query_count: u32,
9134    pub pipeline_statistics: QueryPipelineStatisticFlags,
9135}
9136impl ::std::default::Default for QueryPoolCreateInfo {
9137    fn default() -> Self {
9138        Self {
9139            s_type: StructureType::QUERY_POOL_CREATE_INFO,
9140            p_next: ::std::ptr::null(),
9141            flags: QueryPoolCreateFlags::default(),
9142            query_type: QueryType::default(),
9143            query_count: u32::default(),
9144            pipeline_statistics: QueryPipelineStatisticFlags::default(),
9145        }
9146    }
9147}
9148impl QueryPoolCreateInfo {
9149    pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> {
9150        QueryPoolCreateInfoBuilder {
9151            inner: Self::default(),
9152            marker: ::std::marker::PhantomData,
9153        }
9154    }
9155}
9156#[repr(transparent)]
9157pub struct QueryPoolCreateInfoBuilder<'a> {
9158    inner: QueryPoolCreateInfo,
9159    marker: ::std::marker::PhantomData<&'a ()>,
9160}
9161pub unsafe trait ExtendsQueryPoolCreateInfo {}
9162impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> {
9163    type Target = QueryPoolCreateInfo;
9164    fn deref(&self) -> &Self::Target {
9165        &self.inner
9166    }
9167}
9168impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
9169    fn deref_mut(&mut self) -> &mut Self::Target {
9170        &mut self.inner
9171    }
9172}
9173impl<'a> QueryPoolCreateInfoBuilder<'a> {
9174    pub fn flags(mut self, flags: QueryPoolCreateFlags) -> Self {
9175        self.inner.flags = flags;
9176        self
9177    }
9178    pub fn query_type(mut self, query_type: QueryType) -> Self {
9179        self.inner.query_type = query_type;
9180        self
9181    }
9182    pub fn query_count(mut self, query_count: u32) -> Self {
9183        self.inner.query_count = query_count;
9184        self
9185    }
9186    pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
9187        self.inner.pipeline_statistics = pipeline_statistics;
9188        self
9189    }
9190    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9191    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9192    #[doc = r" valid extension structs can be pushed into the chain."]
9193    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9194    #[doc = r" chain will look like `A -> D -> B -> C`."]
9195    pub fn push_next<T: ExtendsQueryPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
9196        unsafe {
9197            let next_ptr = <*const T>::cast(next);
9198            let last_next = ptr_chain_iter(next).last().unwrap();
9199            (*last_next).p_next = self.inner.p_next as _;
9200            self.inner.p_next = next_ptr;
9201        }
9202        self
9203    }
9204    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9205    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9206    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9207    pub fn build(self) -> QueryPoolCreateInfo {
9208        self.inner
9209    }
9210}
9211#[repr(C)]
9212#[cfg_attr(feature = "debug", derive(Debug))]
9213#[derive(Copy, Clone)]
9214#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateInfo.html>"]
9215pub struct FramebufferCreateInfo {
9216    pub s_type: StructureType,
9217    pub p_next: *const c_void,
9218    pub flags: FramebufferCreateFlags,
9219    pub render_pass: RenderPass,
9220    pub attachment_count: u32,
9221    pub p_attachments: *const ImageView,
9222    pub width: u32,
9223    pub height: u32,
9224    pub layers: u32,
9225}
9226impl ::std::default::Default for FramebufferCreateInfo {
9227    fn default() -> Self {
9228        Self {
9229            s_type: StructureType::FRAMEBUFFER_CREATE_INFO,
9230            p_next: ::std::ptr::null(),
9231            flags: FramebufferCreateFlags::default(),
9232            render_pass: RenderPass::default(),
9233            attachment_count: u32::default(),
9234            p_attachments: ::std::ptr::null(),
9235            width: u32::default(),
9236            height: u32::default(),
9237            layers: u32::default(),
9238        }
9239    }
9240}
9241impl FramebufferCreateInfo {
9242    pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> {
9243        FramebufferCreateInfoBuilder {
9244            inner: Self::default(),
9245            marker: ::std::marker::PhantomData,
9246        }
9247    }
9248}
9249#[repr(transparent)]
9250pub struct FramebufferCreateInfoBuilder<'a> {
9251    inner: FramebufferCreateInfo,
9252    marker: ::std::marker::PhantomData<&'a ()>,
9253}
9254pub unsafe trait ExtendsFramebufferCreateInfo {}
9255impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> {
9256    type Target = FramebufferCreateInfo;
9257    fn deref(&self) -> &Self::Target {
9258        &self.inner
9259    }
9260}
9261impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
9262    fn deref_mut(&mut self) -> &mut Self::Target {
9263        &mut self.inner
9264    }
9265}
9266impl<'a> FramebufferCreateInfoBuilder<'a> {
9267    pub fn flags(mut self, flags: FramebufferCreateFlags) -> Self {
9268        self.inner.flags = flags;
9269        self
9270    }
9271    pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
9272        self.inner.render_pass = render_pass;
9273        self
9274    }
9275    pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
9276        self.inner.attachment_count = attachments.len() as _;
9277        self.inner.p_attachments = attachments.as_ptr();
9278        self
9279    }
9280    pub fn width(mut self, width: u32) -> Self {
9281        self.inner.width = width;
9282        self
9283    }
9284    pub fn height(mut self, height: u32) -> Self {
9285        self.inner.height = height;
9286        self
9287    }
9288    pub fn layers(mut self, layers: u32) -> Self {
9289        self.inner.layers = layers;
9290        self
9291    }
9292    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9293    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9294    #[doc = r" valid extension structs can be pushed into the chain."]
9295    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9296    #[doc = r" chain will look like `A -> D -> B -> C`."]
9297    pub fn push_next<T: ExtendsFramebufferCreateInfo>(mut self, next: &'a mut T) -> Self {
9298        unsafe {
9299            let next_ptr = <*const T>::cast(next);
9300            let last_next = ptr_chain_iter(next).last().unwrap();
9301            (*last_next).p_next = self.inner.p_next as _;
9302            self.inner.p_next = next_ptr;
9303        }
9304        self
9305    }
9306    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9307    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9308    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9309    pub fn build(self) -> FramebufferCreateInfo {
9310        self.inner
9311    }
9312}
9313#[repr(C)]
9314#[cfg_attr(feature = "debug", derive(Debug))]
9315#[derive(Copy, Clone, Default)]
9316#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndirectCommand.html>"]
9317pub struct DrawIndirectCommand {
9318    pub vertex_count: u32,
9319    pub instance_count: u32,
9320    pub first_vertex: u32,
9321    pub first_instance: u32,
9322}
9323impl DrawIndirectCommand {
9324    pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> {
9325        DrawIndirectCommandBuilder {
9326            inner: Self::default(),
9327            marker: ::std::marker::PhantomData,
9328        }
9329    }
9330}
9331#[repr(transparent)]
9332pub struct DrawIndirectCommandBuilder<'a> {
9333    inner: DrawIndirectCommand,
9334    marker: ::std::marker::PhantomData<&'a ()>,
9335}
9336impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> {
9337    type Target = DrawIndirectCommand;
9338    fn deref(&self) -> &Self::Target {
9339        &self.inner
9340    }
9341}
9342impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> {
9343    fn deref_mut(&mut self) -> &mut Self::Target {
9344        &mut self.inner
9345    }
9346}
9347impl<'a> DrawIndirectCommandBuilder<'a> {
9348    pub fn vertex_count(mut self, vertex_count: u32) -> Self {
9349        self.inner.vertex_count = vertex_count;
9350        self
9351    }
9352    pub fn instance_count(mut self, instance_count: u32) -> Self {
9353        self.inner.instance_count = instance_count;
9354        self
9355    }
9356    pub fn first_vertex(mut self, first_vertex: u32) -> Self {
9357        self.inner.first_vertex = first_vertex;
9358        self
9359    }
9360    pub fn first_instance(mut self, first_instance: u32) -> Self {
9361        self.inner.first_instance = first_instance;
9362        self
9363    }
9364    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9365    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9366    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9367    pub fn build(self) -> DrawIndirectCommand {
9368        self.inner
9369    }
9370}
9371#[repr(C)]
9372#[cfg_attr(feature = "debug", derive(Debug))]
9373#[derive(Copy, Clone, Default)]
9374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndexedIndirectCommand.html>"]
9375pub struct DrawIndexedIndirectCommand {
9376    pub index_count: u32,
9377    pub instance_count: u32,
9378    pub first_index: u32,
9379    pub vertex_offset: i32,
9380    pub first_instance: u32,
9381}
9382impl DrawIndexedIndirectCommand {
9383    pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> {
9384        DrawIndexedIndirectCommandBuilder {
9385            inner: Self::default(),
9386            marker: ::std::marker::PhantomData,
9387        }
9388    }
9389}
9390#[repr(transparent)]
9391pub struct DrawIndexedIndirectCommandBuilder<'a> {
9392    inner: DrawIndexedIndirectCommand,
9393    marker: ::std::marker::PhantomData<&'a ()>,
9394}
9395impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> {
9396    type Target = DrawIndexedIndirectCommand;
9397    fn deref(&self) -> &Self::Target {
9398        &self.inner
9399    }
9400}
9401impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> {
9402    fn deref_mut(&mut self) -> &mut Self::Target {
9403        &mut self.inner
9404    }
9405}
9406impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
9407    pub fn index_count(mut self, index_count: u32) -> Self {
9408        self.inner.index_count = index_count;
9409        self
9410    }
9411    pub fn instance_count(mut self, instance_count: u32) -> Self {
9412        self.inner.instance_count = instance_count;
9413        self
9414    }
9415    pub fn first_index(mut self, first_index: u32) -> Self {
9416        self.inner.first_index = first_index;
9417        self
9418    }
9419    pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
9420        self.inner.vertex_offset = vertex_offset;
9421        self
9422    }
9423    pub fn first_instance(mut self, first_instance: u32) -> Self {
9424        self.inner.first_instance = first_instance;
9425        self
9426    }
9427    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9428    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9429    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9430    pub fn build(self) -> DrawIndexedIndirectCommand {
9431        self.inner
9432    }
9433}
9434#[repr(C)]
9435#[cfg_attr(feature = "debug", derive(Debug))]
9436#[derive(Copy, Clone, Default)]
9437#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDispatchIndirectCommand.html>"]
9438pub struct DispatchIndirectCommand {
9439    pub x: u32,
9440    pub y: u32,
9441    pub z: u32,
9442}
9443impl DispatchIndirectCommand {
9444    pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> {
9445        DispatchIndirectCommandBuilder {
9446            inner: Self::default(),
9447            marker: ::std::marker::PhantomData,
9448        }
9449    }
9450}
9451#[repr(transparent)]
9452pub struct DispatchIndirectCommandBuilder<'a> {
9453    inner: DispatchIndirectCommand,
9454    marker: ::std::marker::PhantomData<&'a ()>,
9455}
9456impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> {
9457    type Target = DispatchIndirectCommand;
9458    fn deref(&self) -> &Self::Target {
9459        &self.inner
9460    }
9461}
9462impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> {
9463    fn deref_mut(&mut self) -> &mut Self::Target {
9464        &mut self.inner
9465    }
9466}
9467impl<'a> DispatchIndirectCommandBuilder<'a> {
9468    pub fn x(mut self, x: u32) -> Self {
9469        self.inner.x = x;
9470        self
9471    }
9472    pub fn y(mut self, y: u32) -> Self {
9473        self.inner.y = y;
9474        self
9475    }
9476    pub fn z(mut self, z: u32) -> Self {
9477        self.inner.z = z;
9478        self
9479    }
9480    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9481    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9482    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9483    pub fn build(self) -> DispatchIndirectCommand {
9484        self.inner
9485    }
9486}
9487#[repr(C)]
9488#[cfg_attr(feature = "debug", derive(Debug))]
9489#[derive(Copy, Clone, Default)]
9490#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawInfoEXT.html>"]
9491pub struct MultiDrawInfoEXT {
9492    pub first_vertex: u32,
9493    pub vertex_count: u32,
9494}
9495impl MultiDrawInfoEXT {
9496    pub fn builder<'a>() -> MultiDrawInfoEXTBuilder<'a> {
9497        MultiDrawInfoEXTBuilder {
9498            inner: Self::default(),
9499            marker: ::std::marker::PhantomData,
9500        }
9501    }
9502}
9503#[repr(transparent)]
9504pub struct MultiDrawInfoEXTBuilder<'a> {
9505    inner: MultiDrawInfoEXT,
9506    marker: ::std::marker::PhantomData<&'a ()>,
9507}
9508impl<'a> ::std::ops::Deref for MultiDrawInfoEXTBuilder<'a> {
9509    type Target = MultiDrawInfoEXT;
9510    fn deref(&self) -> &Self::Target {
9511        &self.inner
9512    }
9513}
9514impl<'a> ::std::ops::DerefMut for MultiDrawInfoEXTBuilder<'a> {
9515    fn deref_mut(&mut self) -> &mut Self::Target {
9516        &mut self.inner
9517    }
9518}
9519impl<'a> MultiDrawInfoEXTBuilder<'a> {
9520    pub fn first_vertex(mut self, first_vertex: u32) -> Self {
9521        self.inner.first_vertex = first_vertex;
9522        self
9523    }
9524    pub fn vertex_count(mut self, vertex_count: u32) -> Self {
9525        self.inner.vertex_count = vertex_count;
9526        self
9527    }
9528    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9529    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9530    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9531    pub fn build(self) -> MultiDrawInfoEXT {
9532        self.inner
9533    }
9534}
9535#[repr(C)]
9536#[cfg_attr(feature = "debug", derive(Debug))]
9537#[derive(Copy, Clone, Default)]
9538#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawIndexedInfoEXT.html>"]
9539pub struct MultiDrawIndexedInfoEXT {
9540    pub first_index: u32,
9541    pub index_count: u32,
9542    pub vertex_offset: i32,
9543}
9544impl MultiDrawIndexedInfoEXT {
9545    pub fn builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a> {
9546        MultiDrawIndexedInfoEXTBuilder {
9547            inner: Self::default(),
9548            marker: ::std::marker::PhantomData,
9549        }
9550    }
9551}
9552#[repr(transparent)]
9553pub struct MultiDrawIndexedInfoEXTBuilder<'a> {
9554    inner: MultiDrawIndexedInfoEXT,
9555    marker: ::std::marker::PhantomData<&'a ()>,
9556}
9557impl<'a> ::std::ops::Deref for MultiDrawIndexedInfoEXTBuilder<'a> {
9558    type Target = MultiDrawIndexedInfoEXT;
9559    fn deref(&self) -> &Self::Target {
9560        &self.inner
9561    }
9562}
9563impl<'a> ::std::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder<'a> {
9564    fn deref_mut(&mut self) -> &mut Self::Target {
9565        &mut self.inner
9566    }
9567}
9568impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> {
9569    pub fn first_index(mut self, first_index: u32) -> Self {
9570        self.inner.first_index = first_index;
9571        self
9572    }
9573    pub fn index_count(mut self, index_count: u32) -> Self {
9574        self.inner.index_count = index_count;
9575        self
9576    }
9577    pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
9578        self.inner.vertex_offset = vertex_offset;
9579        self
9580    }
9581    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9582    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9583    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9584    pub fn build(self) -> MultiDrawIndexedInfoEXT {
9585        self.inner
9586    }
9587}
9588#[repr(C)]
9589#[cfg_attr(feature = "debug", derive(Debug))]
9590#[derive(Copy, Clone)]
9591#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo.html>"]
9592pub struct SubmitInfo {
9593    pub s_type: StructureType,
9594    pub p_next: *const c_void,
9595    pub wait_semaphore_count: u32,
9596    pub p_wait_semaphores: *const Semaphore,
9597    pub p_wait_dst_stage_mask: *const PipelineStageFlags,
9598    pub command_buffer_count: u32,
9599    pub p_command_buffers: *const CommandBuffer,
9600    pub signal_semaphore_count: u32,
9601    pub p_signal_semaphores: *const Semaphore,
9602}
9603impl ::std::default::Default for SubmitInfo {
9604    fn default() -> Self {
9605        Self {
9606            s_type: StructureType::SUBMIT_INFO,
9607            p_next: ::std::ptr::null(),
9608            wait_semaphore_count: u32::default(),
9609            p_wait_semaphores: ::std::ptr::null(),
9610            p_wait_dst_stage_mask: ::std::ptr::null(),
9611            command_buffer_count: u32::default(),
9612            p_command_buffers: ::std::ptr::null(),
9613            signal_semaphore_count: u32::default(),
9614            p_signal_semaphores: ::std::ptr::null(),
9615        }
9616    }
9617}
9618impl SubmitInfo {
9619    pub fn builder<'a>() -> SubmitInfoBuilder<'a> {
9620        SubmitInfoBuilder {
9621            inner: Self::default(),
9622            marker: ::std::marker::PhantomData,
9623        }
9624    }
9625}
9626#[repr(transparent)]
9627pub struct SubmitInfoBuilder<'a> {
9628    inner: SubmitInfo,
9629    marker: ::std::marker::PhantomData<&'a ()>,
9630}
9631pub unsafe trait ExtendsSubmitInfo {}
9632impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> {
9633    type Target = SubmitInfo;
9634    fn deref(&self) -> &Self::Target {
9635        &self.inner
9636    }
9637}
9638impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> {
9639    fn deref_mut(&mut self) -> &mut Self::Target {
9640        &mut self.inner
9641    }
9642}
9643impl<'a> SubmitInfoBuilder<'a> {
9644    pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
9645        self.inner.wait_semaphore_count = wait_semaphores.len() as _;
9646        self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
9647        self
9648    }
9649    pub fn wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self {
9650        self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _;
9651        self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr();
9652        self
9653    }
9654    pub fn command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self {
9655        self.inner.command_buffer_count = command_buffers.len() as _;
9656        self.inner.p_command_buffers = command_buffers.as_ptr();
9657        self
9658    }
9659    pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
9660        self.inner.signal_semaphore_count = signal_semaphores.len() as _;
9661        self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
9662        self
9663    }
9664    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
9665    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
9666    #[doc = r" valid extension structs can be pushed into the chain."]
9667    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
9668    #[doc = r" chain will look like `A -> D -> B -> C`."]
9669    pub fn push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> Self {
9670        unsafe {
9671            let next_ptr = <*const T>::cast(next);
9672            let last_next = ptr_chain_iter(next).last().unwrap();
9673            (*last_next).p_next = self.inner.p_next as _;
9674            self.inner.p_next = next_ptr;
9675        }
9676        self
9677    }
9678    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9679    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9680    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9681    pub fn build(self) -> SubmitInfo {
9682        self.inner
9683    }
9684}
9685#[repr(C)]
9686#[cfg_attr(feature = "debug", derive(Debug))]
9687#[derive(Copy, Clone)]
9688#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPropertiesKHR.html>"]
9689pub struct DisplayPropertiesKHR {
9690    pub display: DisplayKHR,
9691    pub display_name: *const c_char,
9692    pub physical_dimensions: Extent2D,
9693    pub physical_resolution: Extent2D,
9694    pub supported_transforms: SurfaceTransformFlagsKHR,
9695    pub plane_reorder_possible: Bool32,
9696    pub persistent_content: Bool32,
9697}
9698impl ::std::default::Default for DisplayPropertiesKHR {
9699    fn default() -> Self {
9700        Self {
9701            display: DisplayKHR::default(),
9702            display_name: ::std::ptr::null(),
9703            physical_dimensions: Extent2D::default(),
9704            physical_resolution: Extent2D::default(),
9705            supported_transforms: SurfaceTransformFlagsKHR::default(),
9706            plane_reorder_possible: Bool32::default(),
9707            persistent_content: Bool32::default(),
9708        }
9709    }
9710}
9711impl DisplayPropertiesKHR {
9712    pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> {
9713        DisplayPropertiesKHRBuilder {
9714            inner: Self::default(),
9715            marker: ::std::marker::PhantomData,
9716        }
9717    }
9718}
9719#[repr(transparent)]
9720pub struct DisplayPropertiesKHRBuilder<'a> {
9721    inner: DisplayPropertiesKHR,
9722    marker: ::std::marker::PhantomData<&'a ()>,
9723}
9724impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> {
9725    type Target = DisplayPropertiesKHR;
9726    fn deref(&self) -> &Self::Target {
9727        &self.inner
9728    }
9729}
9730impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> {
9731    fn deref_mut(&mut self) -> &mut Self::Target {
9732        &mut self.inner
9733    }
9734}
9735impl<'a> DisplayPropertiesKHRBuilder<'a> {
9736    pub fn display(mut self, display: DisplayKHR) -> Self {
9737        self.inner.display = display;
9738        self
9739    }
9740    pub fn display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self {
9741        self.inner.display_name = display_name.as_ptr();
9742        self
9743    }
9744    pub fn physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self {
9745        self.inner.physical_dimensions = physical_dimensions;
9746        self
9747    }
9748    pub fn physical_resolution(mut self, physical_resolution: Extent2D) -> Self {
9749        self.inner.physical_resolution = physical_resolution;
9750        self
9751    }
9752    pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
9753        self.inner.supported_transforms = supported_transforms;
9754        self
9755    }
9756    pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self {
9757        self.inner.plane_reorder_possible = plane_reorder_possible.into();
9758        self
9759    }
9760    pub fn persistent_content(mut self, persistent_content: bool) -> Self {
9761        self.inner.persistent_content = persistent_content.into();
9762        self
9763    }
9764    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9765    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9766    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9767    pub fn build(self) -> DisplayPropertiesKHR {
9768        self.inner
9769    }
9770}
9771#[repr(C)]
9772#[cfg_attr(feature = "debug", derive(Debug))]
9773#[derive(Copy, Clone, Default)]
9774#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlanePropertiesKHR.html>"]
9775pub struct DisplayPlanePropertiesKHR {
9776    pub current_display: DisplayKHR,
9777    pub current_stack_index: u32,
9778}
9779impl DisplayPlanePropertiesKHR {
9780    pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> {
9781        DisplayPlanePropertiesKHRBuilder {
9782            inner: Self::default(),
9783            marker: ::std::marker::PhantomData,
9784        }
9785    }
9786}
9787#[repr(transparent)]
9788pub struct DisplayPlanePropertiesKHRBuilder<'a> {
9789    inner: DisplayPlanePropertiesKHR,
9790    marker: ::std::marker::PhantomData<&'a ()>,
9791}
9792impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> {
9793    type Target = DisplayPlanePropertiesKHR;
9794    fn deref(&self) -> &Self::Target {
9795        &self.inner
9796    }
9797}
9798impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> {
9799    fn deref_mut(&mut self) -> &mut Self::Target {
9800        &mut self.inner
9801    }
9802}
9803impl<'a> DisplayPlanePropertiesKHRBuilder<'a> {
9804    pub fn current_display(mut self, current_display: DisplayKHR) -> Self {
9805        self.inner.current_display = current_display;
9806        self
9807    }
9808    pub fn current_stack_index(mut self, current_stack_index: u32) -> Self {
9809        self.inner.current_stack_index = current_stack_index;
9810        self
9811    }
9812    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9813    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9814    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9815    pub fn build(self) -> DisplayPlanePropertiesKHR {
9816        self.inner
9817    }
9818}
9819#[repr(C)]
9820#[cfg_attr(feature = "debug", derive(Debug))]
9821#[derive(Copy, Clone, Default)]
9822#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeParametersKHR.html>"]
9823pub struct DisplayModeParametersKHR {
9824    pub visible_region: Extent2D,
9825    pub refresh_rate: u32,
9826}
9827impl DisplayModeParametersKHR {
9828    pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> {
9829        DisplayModeParametersKHRBuilder {
9830            inner: Self::default(),
9831            marker: ::std::marker::PhantomData,
9832        }
9833    }
9834}
9835#[repr(transparent)]
9836pub struct DisplayModeParametersKHRBuilder<'a> {
9837    inner: DisplayModeParametersKHR,
9838    marker: ::std::marker::PhantomData<&'a ()>,
9839}
9840impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> {
9841    type Target = DisplayModeParametersKHR;
9842    fn deref(&self) -> &Self::Target {
9843        &self.inner
9844    }
9845}
9846impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> {
9847    fn deref_mut(&mut self) -> &mut Self::Target {
9848        &mut self.inner
9849    }
9850}
9851impl<'a> DisplayModeParametersKHRBuilder<'a> {
9852    pub fn visible_region(mut self, visible_region: Extent2D) -> Self {
9853        self.inner.visible_region = visible_region;
9854        self
9855    }
9856    pub fn refresh_rate(mut self, refresh_rate: u32) -> Self {
9857        self.inner.refresh_rate = refresh_rate;
9858        self
9859    }
9860    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9861    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9862    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9863    pub fn build(self) -> DisplayModeParametersKHR {
9864        self.inner
9865    }
9866}
9867#[repr(C)]
9868#[cfg_attr(feature = "debug", derive(Debug))]
9869#[derive(Copy, Clone, Default)]
9870#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModePropertiesKHR.html>"]
9871pub struct DisplayModePropertiesKHR {
9872    pub display_mode: DisplayModeKHR,
9873    pub parameters: DisplayModeParametersKHR,
9874}
9875impl DisplayModePropertiesKHR {
9876    pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> {
9877        DisplayModePropertiesKHRBuilder {
9878            inner: Self::default(),
9879            marker: ::std::marker::PhantomData,
9880        }
9881    }
9882}
9883#[repr(transparent)]
9884pub struct DisplayModePropertiesKHRBuilder<'a> {
9885    inner: DisplayModePropertiesKHR,
9886    marker: ::std::marker::PhantomData<&'a ()>,
9887}
9888impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> {
9889    type Target = DisplayModePropertiesKHR;
9890    fn deref(&self) -> &Self::Target {
9891        &self.inner
9892    }
9893}
9894impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> {
9895    fn deref_mut(&mut self) -> &mut Self::Target {
9896        &mut self.inner
9897    }
9898}
9899impl<'a> DisplayModePropertiesKHRBuilder<'a> {
9900    pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
9901        self.inner.display_mode = display_mode;
9902        self
9903    }
9904    pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
9905        self.inner.parameters = parameters;
9906        self
9907    }
9908    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9909    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9910    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9911    pub fn build(self) -> DisplayModePropertiesKHR {
9912        self.inner
9913    }
9914}
9915#[repr(C)]
9916#[cfg_attr(feature = "debug", derive(Debug))]
9917#[derive(Copy, Clone)]
9918#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateInfoKHR.html>"]
9919pub struct DisplayModeCreateInfoKHR {
9920    pub s_type: StructureType,
9921    pub p_next: *const c_void,
9922    pub flags: DisplayModeCreateFlagsKHR,
9923    pub parameters: DisplayModeParametersKHR,
9924}
9925impl ::std::default::Default for DisplayModeCreateInfoKHR {
9926    fn default() -> Self {
9927        Self {
9928            s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR,
9929            p_next: ::std::ptr::null(),
9930            flags: DisplayModeCreateFlagsKHR::default(),
9931            parameters: DisplayModeParametersKHR::default(),
9932        }
9933    }
9934}
9935impl DisplayModeCreateInfoKHR {
9936    pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> {
9937        DisplayModeCreateInfoKHRBuilder {
9938            inner: Self::default(),
9939            marker: ::std::marker::PhantomData,
9940        }
9941    }
9942}
9943#[repr(transparent)]
9944pub struct DisplayModeCreateInfoKHRBuilder<'a> {
9945    inner: DisplayModeCreateInfoKHR,
9946    marker: ::std::marker::PhantomData<&'a ()>,
9947}
9948impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> {
9949    type Target = DisplayModeCreateInfoKHR;
9950    fn deref(&self) -> &Self::Target {
9951        &self.inner
9952    }
9953}
9954impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> {
9955    fn deref_mut(&mut self) -> &mut Self::Target {
9956        &mut self.inner
9957    }
9958}
9959impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
9960    pub fn flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self {
9961        self.inner.flags = flags;
9962        self
9963    }
9964    pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
9965        self.inner.parameters = parameters;
9966        self
9967    }
9968    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9969    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9970    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
9971    pub fn build(self) -> DisplayModeCreateInfoKHR {
9972        self.inner
9973    }
9974}
9975#[repr(C)]
9976#[cfg_attr(feature = "debug", derive(Debug))]
9977#[derive(Copy, Clone, Default)]
9978#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html>"]
9979pub struct DisplayPlaneCapabilitiesKHR {
9980    pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
9981    pub min_src_position: Offset2D,
9982    pub max_src_position: Offset2D,
9983    pub min_src_extent: Extent2D,
9984    pub max_src_extent: Extent2D,
9985    pub min_dst_position: Offset2D,
9986    pub max_dst_position: Offset2D,
9987    pub min_dst_extent: Extent2D,
9988    pub max_dst_extent: Extent2D,
9989}
9990impl DisplayPlaneCapabilitiesKHR {
9991    pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
9992        DisplayPlaneCapabilitiesKHRBuilder {
9993            inner: Self::default(),
9994            marker: ::std::marker::PhantomData,
9995        }
9996    }
9997}
9998#[repr(transparent)]
9999pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> {
10000    inner: DisplayPlaneCapabilitiesKHR,
10001    marker: ::std::marker::PhantomData<&'a ()>,
10002}
10003impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> {
10004    type Target = DisplayPlaneCapabilitiesKHR;
10005    fn deref(&self) -> &Self::Target {
10006        &self.inner
10007    }
10008}
10009impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> {
10010    fn deref_mut(&mut self) -> &mut Self::Target {
10011        &mut self.inner
10012    }
10013}
10014impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10015    pub fn supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self {
10016        self.inner.supported_alpha = supported_alpha;
10017        self
10018    }
10019    pub fn min_src_position(mut self, min_src_position: Offset2D) -> Self {
10020        self.inner.min_src_position = min_src_position;
10021        self
10022    }
10023    pub fn max_src_position(mut self, max_src_position: Offset2D) -> Self {
10024        self.inner.max_src_position = max_src_position;
10025        self
10026    }
10027    pub fn min_src_extent(mut self, min_src_extent: Extent2D) -> Self {
10028        self.inner.min_src_extent = min_src_extent;
10029        self
10030    }
10031    pub fn max_src_extent(mut self, max_src_extent: Extent2D) -> Self {
10032        self.inner.max_src_extent = max_src_extent;
10033        self
10034    }
10035    pub fn min_dst_position(mut self, min_dst_position: Offset2D) -> Self {
10036        self.inner.min_dst_position = min_dst_position;
10037        self
10038    }
10039    pub fn max_dst_position(mut self, max_dst_position: Offset2D) -> Self {
10040        self.inner.max_dst_position = max_dst_position;
10041        self
10042    }
10043    pub fn min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self {
10044        self.inner.min_dst_extent = min_dst_extent;
10045        self
10046    }
10047    pub fn max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self {
10048        self.inner.max_dst_extent = max_dst_extent;
10049        self
10050    }
10051    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10052    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10053    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10054    pub fn build(self) -> DisplayPlaneCapabilitiesKHR {
10055        self.inner
10056    }
10057}
10058#[repr(C)]
10059#[cfg_attr(feature = "debug", derive(Debug))]
10060#[derive(Copy, Clone)]
10061#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html>"]
10062pub struct DisplaySurfaceCreateInfoKHR {
10063    pub s_type: StructureType,
10064    pub p_next: *const c_void,
10065    pub flags: DisplaySurfaceCreateFlagsKHR,
10066    pub display_mode: DisplayModeKHR,
10067    pub plane_index: u32,
10068    pub plane_stack_index: u32,
10069    pub transform: SurfaceTransformFlagsKHR,
10070    pub global_alpha: f32,
10071    pub alpha_mode: DisplayPlaneAlphaFlagsKHR,
10072    pub image_extent: Extent2D,
10073}
10074impl ::std::default::Default for DisplaySurfaceCreateInfoKHR {
10075    fn default() -> Self {
10076        Self {
10077            s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR,
10078            p_next: ::std::ptr::null(),
10079            flags: DisplaySurfaceCreateFlagsKHR::default(),
10080            display_mode: DisplayModeKHR::default(),
10081            plane_index: u32::default(),
10082            plane_stack_index: u32::default(),
10083            transform: SurfaceTransformFlagsKHR::default(),
10084            global_alpha: f32::default(),
10085            alpha_mode: DisplayPlaneAlphaFlagsKHR::default(),
10086            image_extent: Extent2D::default(),
10087        }
10088    }
10089}
10090impl DisplaySurfaceCreateInfoKHR {
10091    pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
10092        DisplaySurfaceCreateInfoKHRBuilder {
10093            inner: Self::default(),
10094            marker: ::std::marker::PhantomData,
10095        }
10096    }
10097}
10098#[repr(transparent)]
10099pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> {
10100    inner: DisplaySurfaceCreateInfoKHR,
10101    marker: ::std::marker::PhantomData<&'a ()>,
10102}
10103impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> {
10104    type Target = DisplaySurfaceCreateInfoKHR;
10105    fn deref(&self) -> &Self::Target {
10106        &self.inner
10107    }
10108}
10109impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> {
10110    fn deref_mut(&mut self) -> &mut Self::Target {
10111        &mut self.inner
10112    }
10113}
10114impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
10115    pub fn flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self {
10116        self.inner.flags = flags;
10117        self
10118    }
10119    pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
10120        self.inner.display_mode = display_mode;
10121        self
10122    }
10123    pub fn plane_index(mut self, plane_index: u32) -> Self {
10124        self.inner.plane_index = plane_index;
10125        self
10126    }
10127    pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self {
10128        self.inner.plane_stack_index = plane_stack_index;
10129        self
10130    }
10131    pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
10132        self.inner.transform = transform;
10133        self
10134    }
10135    pub fn global_alpha(mut self, global_alpha: f32) -> Self {
10136        self.inner.global_alpha = global_alpha;
10137        self
10138    }
10139    pub fn alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self {
10140        self.inner.alpha_mode = alpha_mode;
10141        self
10142    }
10143    pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
10144        self.inner.image_extent = image_extent;
10145        self
10146    }
10147    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10148    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10149    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10150    pub fn build(self) -> DisplaySurfaceCreateInfoKHR {
10151        self.inner
10152    }
10153}
10154#[repr(C)]
10155#[cfg_attr(feature = "debug", derive(Debug))]
10156#[derive(Copy, Clone)]
10157#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPresentInfoKHR.html>"]
10158pub struct DisplayPresentInfoKHR {
10159    pub s_type: StructureType,
10160    pub p_next: *const c_void,
10161    pub src_rect: Rect2D,
10162    pub dst_rect: Rect2D,
10163    pub persistent: Bool32,
10164}
10165impl ::std::default::Default for DisplayPresentInfoKHR {
10166    fn default() -> Self {
10167        Self {
10168            s_type: StructureType::DISPLAY_PRESENT_INFO_KHR,
10169            p_next: ::std::ptr::null(),
10170            src_rect: Rect2D::default(),
10171            dst_rect: Rect2D::default(),
10172            persistent: Bool32::default(),
10173        }
10174    }
10175}
10176impl DisplayPresentInfoKHR {
10177    pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> {
10178        DisplayPresentInfoKHRBuilder {
10179            inner: Self::default(),
10180            marker: ::std::marker::PhantomData,
10181        }
10182    }
10183}
10184#[repr(transparent)]
10185pub struct DisplayPresentInfoKHRBuilder<'a> {
10186    inner: DisplayPresentInfoKHR,
10187    marker: ::std::marker::PhantomData<&'a ()>,
10188}
10189unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {}
10190unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {}
10191impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> {
10192    type Target = DisplayPresentInfoKHR;
10193    fn deref(&self) -> &Self::Target {
10194        &self.inner
10195    }
10196}
10197impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> {
10198    fn deref_mut(&mut self) -> &mut Self::Target {
10199        &mut self.inner
10200    }
10201}
10202impl<'a> DisplayPresentInfoKHRBuilder<'a> {
10203    pub fn src_rect(mut self, src_rect: Rect2D) -> Self {
10204        self.inner.src_rect = src_rect;
10205        self
10206    }
10207    pub fn dst_rect(mut self, dst_rect: Rect2D) -> Self {
10208        self.inner.dst_rect = dst_rect;
10209        self
10210    }
10211    pub fn persistent(mut self, persistent: bool) -> Self {
10212        self.inner.persistent = persistent.into();
10213        self
10214    }
10215    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10216    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10217    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10218    pub fn build(self) -> DisplayPresentInfoKHR {
10219        self.inner
10220    }
10221}
10222#[repr(C)]
10223#[cfg_attr(feature = "debug", derive(Debug))]
10224#[derive(Copy, Clone, Default)]
10225#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesKHR.html>"]
10226pub struct SurfaceCapabilitiesKHR {
10227    pub min_image_count: u32,
10228    pub max_image_count: u32,
10229    pub current_extent: Extent2D,
10230    pub min_image_extent: Extent2D,
10231    pub max_image_extent: Extent2D,
10232    pub max_image_array_layers: u32,
10233    pub supported_transforms: SurfaceTransformFlagsKHR,
10234    pub current_transform: SurfaceTransformFlagsKHR,
10235    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
10236    pub supported_usage_flags: ImageUsageFlags,
10237}
10238impl SurfaceCapabilitiesKHR {
10239    pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> {
10240        SurfaceCapabilitiesKHRBuilder {
10241            inner: Self::default(),
10242            marker: ::std::marker::PhantomData,
10243        }
10244    }
10245}
10246#[repr(transparent)]
10247pub struct SurfaceCapabilitiesKHRBuilder<'a> {
10248    inner: SurfaceCapabilitiesKHR,
10249    marker: ::std::marker::PhantomData<&'a ()>,
10250}
10251impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> {
10252    type Target = SurfaceCapabilitiesKHR;
10253    fn deref(&self) -> &Self::Target {
10254        &self.inner
10255    }
10256}
10257impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> {
10258    fn deref_mut(&mut self) -> &mut Self::Target {
10259        &mut self.inner
10260    }
10261}
10262impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
10263    pub fn min_image_count(mut self, min_image_count: u32) -> Self {
10264        self.inner.min_image_count = min_image_count;
10265        self
10266    }
10267    pub fn max_image_count(mut self, max_image_count: u32) -> Self {
10268        self.inner.max_image_count = max_image_count;
10269        self
10270    }
10271    pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
10272        self.inner.current_extent = current_extent;
10273        self
10274    }
10275    pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
10276        self.inner.min_image_extent = min_image_extent;
10277        self
10278    }
10279    pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
10280        self.inner.max_image_extent = max_image_extent;
10281        self
10282    }
10283    pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
10284        self.inner.max_image_array_layers = max_image_array_layers;
10285        self
10286    }
10287    pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
10288        self.inner.supported_transforms = supported_transforms;
10289        self
10290    }
10291    pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
10292        self.inner.current_transform = current_transform;
10293        self
10294    }
10295    pub fn supported_composite_alpha(
10296        mut self,
10297        supported_composite_alpha: CompositeAlphaFlagsKHR,
10298    ) -> Self {
10299        self.inner.supported_composite_alpha = supported_composite_alpha;
10300        self
10301    }
10302    pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
10303        self.inner.supported_usage_flags = supported_usage_flags;
10304        self
10305    }
10306    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10307    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10308    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10309    pub fn build(self) -> SurfaceCapabilitiesKHR {
10310        self.inner
10311    }
10312}
10313#[repr(C)]
10314#[cfg_attr(feature = "debug", derive(Debug))]
10315#[derive(Copy, Clone)]
10316#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateInfoKHR.html>"]
10317pub struct AndroidSurfaceCreateInfoKHR {
10318    pub s_type: StructureType,
10319    pub p_next: *const c_void,
10320    pub flags: AndroidSurfaceCreateFlagsKHR,
10321    pub window: *mut ANativeWindow,
10322}
10323impl ::std::default::Default for AndroidSurfaceCreateInfoKHR {
10324    fn default() -> Self {
10325        Self {
10326            s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR,
10327            p_next: ::std::ptr::null(),
10328            flags: AndroidSurfaceCreateFlagsKHR::default(),
10329            window: ::std::ptr::null_mut(),
10330        }
10331    }
10332}
10333impl AndroidSurfaceCreateInfoKHR {
10334    pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
10335        AndroidSurfaceCreateInfoKHRBuilder {
10336            inner: Self::default(),
10337            marker: ::std::marker::PhantomData,
10338        }
10339    }
10340}
10341#[repr(transparent)]
10342pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> {
10343    inner: AndroidSurfaceCreateInfoKHR,
10344    marker: ::std::marker::PhantomData<&'a ()>,
10345}
10346impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> {
10347    type Target = AndroidSurfaceCreateInfoKHR;
10348    fn deref(&self) -> &Self::Target {
10349        &self.inner
10350    }
10351}
10352impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> {
10353    fn deref_mut(&mut self) -> &mut Self::Target {
10354        &mut self.inner
10355    }
10356}
10357impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
10358    pub fn flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self {
10359        self.inner.flags = flags;
10360        self
10361    }
10362    pub fn window(mut self, window: *mut ANativeWindow) -> Self {
10363        self.inner.window = window;
10364        self
10365    }
10366    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10367    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10368    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10369    pub fn build(self) -> AndroidSurfaceCreateInfoKHR {
10370        self.inner
10371    }
10372}
10373#[repr(C)]
10374#[cfg_attr(feature = "debug", derive(Debug))]
10375#[derive(Copy, Clone)]
10376#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateInfoNN.html>"]
10377pub struct ViSurfaceCreateInfoNN {
10378    pub s_type: StructureType,
10379    pub p_next: *const c_void,
10380    pub flags: ViSurfaceCreateFlagsNN,
10381    pub window: *mut c_void,
10382}
10383impl ::std::default::Default for ViSurfaceCreateInfoNN {
10384    fn default() -> Self {
10385        Self {
10386            s_type: StructureType::VI_SURFACE_CREATE_INFO_NN,
10387            p_next: ::std::ptr::null(),
10388            flags: ViSurfaceCreateFlagsNN::default(),
10389            window: ::std::ptr::null_mut(),
10390        }
10391    }
10392}
10393impl ViSurfaceCreateInfoNN {
10394    pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> {
10395        ViSurfaceCreateInfoNNBuilder {
10396            inner: Self::default(),
10397            marker: ::std::marker::PhantomData,
10398        }
10399    }
10400}
10401#[repr(transparent)]
10402pub struct ViSurfaceCreateInfoNNBuilder<'a> {
10403    inner: ViSurfaceCreateInfoNN,
10404    marker: ::std::marker::PhantomData<&'a ()>,
10405}
10406impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> {
10407    type Target = ViSurfaceCreateInfoNN;
10408    fn deref(&self) -> &Self::Target {
10409        &self.inner
10410    }
10411}
10412impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> {
10413    fn deref_mut(&mut self) -> &mut Self::Target {
10414        &mut self.inner
10415    }
10416}
10417impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
10418    pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self {
10419        self.inner.flags = flags;
10420        self
10421    }
10422    pub fn window(mut self, window: *mut c_void) -> Self {
10423        self.inner.window = window;
10424        self
10425    }
10426    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10427    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10428    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10429    pub fn build(self) -> ViSurfaceCreateInfoNN {
10430        self.inner
10431    }
10432}
10433#[repr(C)]
10434#[cfg_attr(feature = "debug", derive(Debug))]
10435#[derive(Copy, Clone)]
10436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateInfoKHR.html>"]
10437pub struct WaylandSurfaceCreateInfoKHR {
10438    pub s_type: StructureType,
10439    pub p_next: *const c_void,
10440    pub flags: WaylandSurfaceCreateFlagsKHR,
10441    pub display: *mut wl_display,
10442    pub surface: *mut wl_surface,
10443}
10444impl ::std::default::Default for WaylandSurfaceCreateInfoKHR {
10445    fn default() -> Self {
10446        Self {
10447            s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR,
10448            p_next: ::std::ptr::null(),
10449            flags: WaylandSurfaceCreateFlagsKHR::default(),
10450            display: ::std::ptr::null_mut(),
10451            surface: ::std::ptr::null_mut(),
10452        }
10453    }
10454}
10455impl WaylandSurfaceCreateInfoKHR {
10456    pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
10457        WaylandSurfaceCreateInfoKHRBuilder {
10458            inner: Self::default(),
10459            marker: ::std::marker::PhantomData,
10460        }
10461    }
10462}
10463#[repr(transparent)]
10464pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> {
10465    inner: WaylandSurfaceCreateInfoKHR,
10466    marker: ::std::marker::PhantomData<&'a ()>,
10467}
10468impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> {
10469    type Target = WaylandSurfaceCreateInfoKHR;
10470    fn deref(&self) -> &Self::Target {
10471        &self.inner
10472    }
10473}
10474impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> {
10475    fn deref_mut(&mut self) -> &mut Self::Target {
10476        &mut self.inner
10477    }
10478}
10479impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
10480    pub fn flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self {
10481        self.inner.flags = flags;
10482        self
10483    }
10484    pub fn display(mut self, display: *mut wl_display) -> Self {
10485        self.inner.display = display;
10486        self
10487    }
10488    pub fn surface(mut self, surface: *mut wl_surface) -> Self {
10489        self.inner.surface = surface;
10490        self
10491    }
10492    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10493    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10494    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10495    pub fn build(self) -> WaylandSurfaceCreateInfoKHR {
10496        self.inner
10497    }
10498}
10499#[repr(C)]
10500#[cfg_attr(feature = "debug", derive(Debug))]
10501#[derive(Copy, Clone)]
10502#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html>"]
10503pub struct Win32SurfaceCreateInfoKHR {
10504    pub s_type: StructureType,
10505    pub p_next: *const c_void,
10506    pub flags: Win32SurfaceCreateFlagsKHR,
10507    pub hinstance: HINSTANCE,
10508    pub hwnd: HWND,
10509}
10510impl ::std::default::Default for Win32SurfaceCreateInfoKHR {
10511    fn default() -> Self {
10512        Self {
10513            s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR,
10514            p_next: ::std::ptr::null(),
10515            flags: Win32SurfaceCreateFlagsKHR::default(),
10516            hinstance: unsafe { ::std::mem::zeroed() },
10517            hwnd: unsafe { ::std::mem::zeroed() },
10518        }
10519    }
10520}
10521impl Win32SurfaceCreateInfoKHR {
10522    pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
10523        Win32SurfaceCreateInfoKHRBuilder {
10524            inner: Self::default(),
10525            marker: ::std::marker::PhantomData,
10526        }
10527    }
10528}
10529#[repr(transparent)]
10530pub struct Win32SurfaceCreateInfoKHRBuilder<'a> {
10531    inner: Win32SurfaceCreateInfoKHR,
10532    marker: ::std::marker::PhantomData<&'a ()>,
10533}
10534impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
10535    type Target = Win32SurfaceCreateInfoKHR;
10536    fn deref(&self) -> &Self::Target {
10537        &self.inner
10538    }
10539}
10540impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
10541    fn deref_mut(&mut self) -> &mut Self::Target {
10542        &mut self.inner
10543    }
10544}
10545impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
10546    pub fn flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self {
10547        self.inner.flags = flags;
10548        self
10549    }
10550    pub fn hinstance(mut self, hinstance: HINSTANCE) -> Self {
10551        self.inner.hinstance = hinstance;
10552        self
10553    }
10554    pub fn hwnd(mut self, hwnd: HWND) -> Self {
10555        self.inner.hwnd = hwnd;
10556        self
10557    }
10558    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10559    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10560    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10561    pub fn build(self) -> Win32SurfaceCreateInfoKHR {
10562        self.inner
10563    }
10564}
10565#[repr(C)]
10566#[cfg_attr(feature = "debug", derive(Debug))]
10567#[derive(Copy, Clone)]
10568#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateInfoKHR.html>"]
10569pub struct XlibSurfaceCreateInfoKHR {
10570    pub s_type: StructureType,
10571    pub p_next: *const c_void,
10572    pub flags: XlibSurfaceCreateFlagsKHR,
10573    pub dpy: *mut Display,
10574    pub window: Window,
10575}
10576impl ::std::default::Default for XlibSurfaceCreateInfoKHR {
10577    fn default() -> Self {
10578        Self {
10579            s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR,
10580            p_next: ::std::ptr::null(),
10581            flags: XlibSurfaceCreateFlagsKHR::default(),
10582            dpy: ::std::ptr::null_mut(),
10583            window: Window::default(),
10584        }
10585    }
10586}
10587impl XlibSurfaceCreateInfoKHR {
10588    pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> {
10589        XlibSurfaceCreateInfoKHRBuilder {
10590            inner: Self::default(),
10591            marker: ::std::marker::PhantomData,
10592        }
10593    }
10594}
10595#[repr(transparent)]
10596pub struct XlibSurfaceCreateInfoKHRBuilder<'a> {
10597    inner: XlibSurfaceCreateInfoKHR,
10598    marker: ::std::marker::PhantomData<&'a ()>,
10599}
10600impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> {
10601    type Target = XlibSurfaceCreateInfoKHR;
10602    fn deref(&self) -> &Self::Target {
10603        &self.inner
10604    }
10605}
10606impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> {
10607    fn deref_mut(&mut self) -> &mut Self::Target {
10608        &mut self.inner
10609    }
10610}
10611impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
10612    pub fn flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self {
10613        self.inner.flags = flags;
10614        self
10615    }
10616    pub fn dpy(mut self, dpy: *mut Display) -> Self {
10617        self.inner.dpy = dpy;
10618        self
10619    }
10620    pub fn window(mut self, window: Window) -> Self {
10621        self.inner.window = window;
10622        self
10623    }
10624    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10625    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10626    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10627    pub fn build(self) -> XlibSurfaceCreateInfoKHR {
10628        self.inner
10629    }
10630}
10631#[repr(C)]
10632#[cfg_attr(feature = "debug", derive(Debug))]
10633#[derive(Copy, Clone)]
10634#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateInfoKHR.html>"]
10635pub struct XcbSurfaceCreateInfoKHR {
10636    pub s_type: StructureType,
10637    pub p_next: *const c_void,
10638    pub flags: XcbSurfaceCreateFlagsKHR,
10639    pub connection: *mut xcb_connection_t,
10640    pub window: xcb_window_t,
10641}
10642impl ::std::default::Default for XcbSurfaceCreateInfoKHR {
10643    fn default() -> Self {
10644        Self {
10645            s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR,
10646            p_next: ::std::ptr::null(),
10647            flags: XcbSurfaceCreateFlagsKHR::default(),
10648            connection: ::std::ptr::null_mut(),
10649            window: xcb_window_t::default(),
10650        }
10651    }
10652}
10653impl XcbSurfaceCreateInfoKHR {
10654    pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
10655        XcbSurfaceCreateInfoKHRBuilder {
10656            inner: Self::default(),
10657            marker: ::std::marker::PhantomData,
10658        }
10659    }
10660}
10661#[repr(transparent)]
10662pub struct XcbSurfaceCreateInfoKHRBuilder<'a> {
10663    inner: XcbSurfaceCreateInfoKHR,
10664    marker: ::std::marker::PhantomData<&'a ()>,
10665}
10666impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
10667    type Target = XcbSurfaceCreateInfoKHR;
10668    fn deref(&self) -> &Self::Target {
10669        &self.inner
10670    }
10671}
10672impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
10673    fn deref_mut(&mut self) -> &mut Self::Target {
10674        &mut self.inner
10675    }
10676}
10677impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
10678    pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self {
10679        self.inner.flags = flags;
10680        self
10681    }
10682    pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self {
10683        self.inner.connection = connection;
10684        self
10685    }
10686    pub fn window(mut self, window: xcb_window_t) -> Self {
10687        self.inner.window = window;
10688        self
10689    }
10690    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10691    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10692    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10693    pub fn build(self) -> XcbSurfaceCreateInfoKHR {
10694        self.inner
10695    }
10696}
10697#[repr(C)]
10698#[cfg_attr(feature = "debug", derive(Debug))]
10699#[derive(Copy, Clone)]
10700#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateInfoEXT.html>"]
10701pub struct DirectFBSurfaceCreateInfoEXT {
10702    pub s_type: StructureType,
10703    pub p_next: *const c_void,
10704    pub flags: DirectFBSurfaceCreateFlagsEXT,
10705    pub dfb: *mut IDirectFB,
10706    pub surface: *mut IDirectFBSurface,
10707}
10708impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT {
10709    fn default() -> Self {
10710        Self {
10711            s_type: StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT,
10712            p_next: ::std::ptr::null(),
10713            flags: DirectFBSurfaceCreateFlagsEXT::default(),
10714            dfb: ::std::ptr::null_mut(),
10715            surface: ::std::ptr::null_mut(),
10716        }
10717    }
10718}
10719impl DirectFBSurfaceCreateInfoEXT {
10720    pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10721        DirectFBSurfaceCreateInfoEXTBuilder {
10722            inner: Self::default(),
10723            marker: ::std::marker::PhantomData,
10724        }
10725    }
10726}
10727#[repr(transparent)]
10728pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10729    inner: DirectFBSurfaceCreateInfoEXT,
10730    marker: ::std::marker::PhantomData<&'a ()>,
10731}
10732impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10733    type Target = DirectFBSurfaceCreateInfoEXT;
10734    fn deref(&self) -> &Self::Target {
10735        &self.inner
10736    }
10737}
10738impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10739    fn deref_mut(&mut self) -> &mut Self::Target {
10740        &mut self.inner
10741    }
10742}
10743impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
10744    pub fn flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self {
10745        self.inner.flags = flags;
10746        self
10747    }
10748    pub fn dfb(mut self, dfb: *mut IDirectFB) -> Self {
10749        self.inner.dfb = dfb;
10750        self
10751    }
10752    pub fn surface(mut self, surface: *mut IDirectFBSurface) -> Self {
10753        self.inner.surface = surface;
10754        self
10755    }
10756    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10757    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10758    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10759    pub fn build(self) -> DirectFBSurfaceCreateInfoEXT {
10760        self.inner
10761    }
10762}
10763#[repr(C)]
10764#[cfg_attr(feature = "debug", derive(Debug))]
10765#[derive(Copy, Clone)]
10766#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>"]
10767pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
10768    pub s_type: StructureType,
10769    pub p_next: *const c_void,
10770    pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
10771    pub image_pipe_handle: zx_handle_t,
10772}
10773impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA {
10774    fn default() -> Self {
10775        Self {
10776            s_type: StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
10777            p_next: ::std::ptr::null(),
10778            flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(),
10779            image_pipe_handle: zx_handle_t::default(),
10780        }
10781    }
10782}
10783impl ImagePipeSurfaceCreateInfoFUCHSIA {
10784    pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10785        ImagePipeSurfaceCreateInfoFUCHSIABuilder {
10786            inner: Self::default(),
10787            marker: ::std::marker::PhantomData,
10788        }
10789    }
10790}
10791#[repr(transparent)]
10792pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10793    inner: ImagePipeSurfaceCreateInfoFUCHSIA,
10794    marker: ::std::marker::PhantomData<&'a ()>,
10795}
10796impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10797    type Target = ImagePipeSurfaceCreateInfoFUCHSIA;
10798    fn deref(&self) -> &Self::Target {
10799        &self.inner
10800    }
10801}
10802impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10803    fn deref_mut(&mut self) -> &mut Self::Target {
10804        &mut self.inner
10805    }
10806}
10807impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
10808    pub fn flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self {
10809        self.inner.flags = flags;
10810        self
10811    }
10812    pub fn image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self {
10813        self.inner.image_pipe_handle = image_pipe_handle;
10814        self
10815    }
10816    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10817    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10818    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10819    pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA {
10820        self.inner
10821    }
10822}
10823#[repr(C)]
10824#[cfg_attr(feature = "debug", derive(Debug))]
10825#[derive(Copy, Clone)]
10826#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>"]
10827pub struct StreamDescriptorSurfaceCreateInfoGGP {
10828    pub s_type: StructureType,
10829    pub p_next: *const c_void,
10830    pub flags: StreamDescriptorSurfaceCreateFlagsGGP,
10831    pub stream_descriptor: GgpStreamDescriptor,
10832}
10833impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP {
10834    fn default() -> Self {
10835        Self {
10836            s_type: StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
10837            p_next: ::std::ptr::null(),
10838            flags: StreamDescriptorSurfaceCreateFlagsGGP::default(),
10839            stream_descriptor: GgpStreamDescriptor::default(),
10840        }
10841    }
10842}
10843impl StreamDescriptorSurfaceCreateInfoGGP {
10844    pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10845        StreamDescriptorSurfaceCreateInfoGGPBuilder {
10846            inner: Self::default(),
10847            marker: ::std::marker::PhantomData,
10848        }
10849    }
10850}
10851#[repr(transparent)]
10852pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10853    inner: StreamDescriptorSurfaceCreateInfoGGP,
10854    marker: ::std::marker::PhantomData<&'a ()>,
10855}
10856impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10857    type Target = StreamDescriptorSurfaceCreateInfoGGP;
10858    fn deref(&self) -> &Self::Target {
10859        &self.inner
10860    }
10861}
10862impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10863    fn deref_mut(&mut self) -> &mut Self::Target {
10864        &mut self.inner
10865    }
10866}
10867impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
10868    pub fn flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self {
10869        self.inner.flags = flags;
10870        self
10871    }
10872    pub fn stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self {
10873        self.inner.stream_descriptor = stream_descriptor;
10874        self
10875    }
10876    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10877    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10878    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10879    pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP {
10880        self.inner
10881    }
10882}
10883#[repr(C)]
10884#[cfg_attr(feature = "debug", derive(Debug))]
10885#[derive(Copy, Clone)]
10886#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateInfoQNX.html>"]
10887pub struct ScreenSurfaceCreateInfoQNX {
10888    pub s_type: StructureType,
10889    pub p_next: *const c_void,
10890    pub flags: ScreenSurfaceCreateFlagsQNX,
10891    pub context: *mut _screen_context,
10892    pub window: *mut _screen_window,
10893}
10894impl ::std::default::Default for ScreenSurfaceCreateInfoQNX {
10895    fn default() -> Self {
10896        Self {
10897            s_type: StructureType::SCREEN_SURFACE_CREATE_INFO_QNX,
10898            p_next: ::std::ptr::null(),
10899            flags: ScreenSurfaceCreateFlagsQNX::default(),
10900            context: ::std::ptr::null_mut(),
10901            window: ::std::ptr::null_mut(),
10902        }
10903    }
10904}
10905impl ScreenSurfaceCreateInfoQNX {
10906    pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> {
10907        ScreenSurfaceCreateInfoQNXBuilder {
10908            inner: Self::default(),
10909            marker: ::std::marker::PhantomData,
10910        }
10911    }
10912}
10913#[repr(transparent)]
10914pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> {
10915    inner: ScreenSurfaceCreateInfoQNX,
10916    marker: ::std::marker::PhantomData<&'a ()>,
10917}
10918impl<'a> ::std::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> {
10919    type Target = ScreenSurfaceCreateInfoQNX;
10920    fn deref(&self) -> &Self::Target {
10921        &self.inner
10922    }
10923}
10924impl<'a> ::std::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> {
10925    fn deref_mut(&mut self) -> &mut Self::Target {
10926        &mut self.inner
10927    }
10928}
10929impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> {
10930    pub fn flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self {
10931        self.inner.flags = flags;
10932        self
10933    }
10934    pub fn context(mut self, context: &'a mut _screen_context) -> Self {
10935        self.inner.context = context;
10936        self
10937    }
10938    pub fn window(mut self, window: &'a mut _screen_window) -> Self {
10939        self.inner.window = window;
10940        self
10941    }
10942    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10943    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10944    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10945    pub fn build(self) -> ScreenSurfaceCreateInfoQNX {
10946        self.inner
10947    }
10948}
10949#[repr(C)]
10950#[cfg_attr(feature = "debug", derive(Debug))]
10951#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
10952#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormatKHR.html>"]
10953pub struct SurfaceFormatKHR {
10954    pub format: Format,
10955    pub color_space: ColorSpaceKHR,
10956}
10957impl SurfaceFormatKHR {
10958    pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> {
10959        SurfaceFormatKHRBuilder {
10960            inner: Self::default(),
10961            marker: ::std::marker::PhantomData,
10962        }
10963    }
10964}
10965#[repr(transparent)]
10966pub struct SurfaceFormatKHRBuilder<'a> {
10967    inner: SurfaceFormatKHR,
10968    marker: ::std::marker::PhantomData<&'a ()>,
10969}
10970impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> {
10971    type Target = SurfaceFormatKHR;
10972    fn deref(&self) -> &Self::Target {
10973        &self.inner
10974    }
10975}
10976impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> {
10977    fn deref_mut(&mut self) -> &mut Self::Target {
10978        &mut self.inner
10979    }
10980}
10981impl<'a> SurfaceFormatKHRBuilder<'a> {
10982    pub fn format(mut self, format: Format) -> Self {
10983        self.inner.format = format;
10984        self
10985    }
10986    pub fn color_space(mut self, color_space: ColorSpaceKHR) -> Self {
10987        self.inner.color_space = color_space;
10988        self
10989    }
10990    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10991    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10992    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
10993    pub fn build(self) -> SurfaceFormatKHR {
10994        self.inner
10995    }
10996}
10997#[repr(C)]
10998#[cfg_attr(feature = "debug", derive(Debug))]
10999#[derive(Copy, Clone)]
11000#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateInfoKHR.html>"]
11001pub struct SwapchainCreateInfoKHR {
11002    pub s_type: StructureType,
11003    pub p_next: *const c_void,
11004    pub flags: SwapchainCreateFlagsKHR,
11005    pub surface: SurfaceKHR,
11006    pub min_image_count: u32,
11007    pub image_format: Format,
11008    pub image_color_space: ColorSpaceKHR,
11009    pub image_extent: Extent2D,
11010    pub image_array_layers: u32,
11011    pub image_usage: ImageUsageFlags,
11012    pub image_sharing_mode: SharingMode,
11013    pub queue_family_index_count: u32,
11014    pub p_queue_family_indices: *const u32,
11015    pub pre_transform: SurfaceTransformFlagsKHR,
11016    pub composite_alpha: CompositeAlphaFlagsKHR,
11017    pub present_mode: PresentModeKHR,
11018    pub clipped: Bool32,
11019    pub old_swapchain: SwapchainKHR,
11020}
11021impl ::std::default::Default for SwapchainCreateInfoKHR {
11022    fn default() -> Self {
11023        Self {
11024            s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR,
11025            p_next: ::std::ptr::null(),
11026            flags: SwapchainCreateFlagsKHR::default(),
11027            surface: SurfaceKHR::default(),
11028            min_image_count: u32::default(),
11029            image_format: Format::default(),
11030            image_color_space: ColorSpaceKHR::default(),
11031            image_extent: Extent2D::default(),
11032            image_array_layers: u32::default(),
11033            image_usage: ImageUsageFlags::default(),
11034            image_sharing_mode: SharingMode::default(),
11035            queue_family_index_count: u32::default(),
11036            p_queue_family_indices: ::std::ptr::null(),
11037            pre_transform: SurfaceTransformFlagsKHR::default(),
11038            composite_alpha: CompositeAlphaFlagsKHR::default(),
11039            present_mode: PresentModeKHR::default(),
11040            clipped: Bool32::default(),
11041            old_swapchain: SwapchainKHR::default(),
11042        }
11043    }
11044}
11045impl SwapchainCreateInfoKHR {
11046    pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> {
11047        SwapchainCreateInfoKHRBuilder {
11048            inner: Self::default(),
11049            marker: ::std::marker::PhantomData,
11050        }
11051    }
11052}
11053#[repr(transparent)]
11054pub struct SwapchainCreateInfoKHRBuilder<'a> {
11055    inner: SwapchainCreateInfoKHR,
11056    marker: ::std::marker::PhantomData<&'a ()>,
11057}
11058pub unsafe trait ExtendsSwapchainCreateInfoKHR {}
11059impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> {
11060    type Target = SwapchainCreateInfoKHR;
11061    fn deref(&self) -> &Self::Target {
11062        &self.inner
11063    }
11064}
11065impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> {
11066    fn deref_mut(&mut self) -> &mut Self::Target {
11067        &mut self.inner
11068    }
11069}
11070impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
11071    pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self {
11072        self.inner.flags = flags;
11073        self
11074    }
11075    pub fn surface(mut self, surface: SurfaceKHR) -> Self {
11076        self.inner.surface = surface;
11077        self
11078    }
11079    pub fn min_image_count(mut self, min_image_count: u32) -> Self {
11080        self.inner.min_image_count = min_image_count;
11081        self
11082    }
11083    pub fn image_format(mut self, image_format: Format) -> Self {
11084        self.inner.image_format = image_format;
11085        self
11086    }
11087    pub fn image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self {
11088        self.inner.image_color_space = image_color_space;
11089        self
11090    }
11091    pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
11092        self.inner.image_extent = image_extent;
11093        self
11094    }
11095    pub fn image_array_layers(mut self, image_array_layers: u32) -> Self {
11096        self.inner.image_array_layers = image_array_layers;
11097        self
11098    }
11099    pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
11100        self.inner.image_usage = image_usage;
11101        self
11102    }
11103    pub fn image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self {
11104        self.inner.image_sharing_mode = image_sharing_mode;
11105        self
11106    }
11107    pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
11108        self.inner.queue_family_index_count = queue_family_indices.len() as _;
11109        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
11110        self
11111    }
11112    pub fn pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self {
11113        self.inner.pre_transform = pre_transform;
11114        self
11115    }
11116    pub fn composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self {
11117        self.inner.composite_alpha = composite_alpha;
11118        self
11119    }
11120    pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self {
11121        self.inner.present_mode = present_mode;
11122        self
11123    }
11124    pub fn clipped(mut self, clipped: bool) -> Self {
11125        self.inner.clipped = clipped.into();
11126        self
11127    }
11128    pub fn old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self {
11129        self.inner.old_swapchain = old_swapchain;
11130        self
11131    }
11132    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11133    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11134    #[doc = r" valid extension structs can be pushed into the chain."]
11135    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11136    #[doc = r" chain will look like `A -> D -> B -> C`."]
11137    pub fn push_next<T: ExtendsSwapchainCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
11138        unsafe {
11139            let next_ptr = <*const T>::cast(next);
11140            let last_next = ptr_chain_iter(next).last().unwrap();
11141            (*last_next).p_next = self.inner.p_next as _;
11142            self.inner.p_next = next_ptr;
11143        }
11144        self
11145    }
11146    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11147    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11148    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11149    pub fn build(self) -> SwapchainCreateInfoKHR {
11150        self.inner
11151    }
11152}
11153#[repr(C)]
11154#[cfg_attr(feature = "debug", derive(Debug))]
11155#[derive(Copy, Clone)]
11156#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentInfoKHR.html>"]
11157pub struct PresentInfoKHR {
11158    pub s_type: StructureType,
11159    pub p_next: *const c_void,
11160    pub wait_semaphore_count: u32,
11161    pub p_wait_semaphores: *const Semaphore,
11162    pub swapchain_count: u32,
11163    pub p_swapchains: *const SwapchainKHR,
11164    pub p_image_indices: *const u32,
11165    pub p_results: *mut Result,
11166}
11167impl ::std::default::Default for PresentInfoKHR {
11168    fn default() -> Self {
11169        Self {
11170            s_type: StructureType::PRESENT_INFO_KHR,
11171            p_next: ::std::ptr::null(),
11172            wait_semaphore_count: u32::default(),
11173            p_wait_semaphores: ::std::ptr::null(),
11174            swapchain_count: u32::default(),
11175            p_swapchains: ::std::ptr::null(),
11176            p_image_indices: ::std::ptr::null(),
11177            p_results: ::std::ptr::null_mut(),
11178        }
11179    }
11180}
11181impl PresentInfoKHR {
11182    pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> {
11183        PresentInfoKHRBuilder {
11184            inner: Self::default(),
11185            marker: ::std::marker::PhantomData,
11186        }
11187    }
11188}
11189#[repr(transparent)]
11190pub struct PresentInfoKHRBuilder<'a> {
11191    inner: PresentInfoKHR,
11192    marker: ::std::marker::PhantomData<&'a ()>,
11193}
11194pub unsafe trait ExtendsPresentInfoKHR {}
11195impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> {
11196    type Target = PresentInfoKHR;
11197    fn deref(&self) -> &Self::Target {
11198        &self.inner
11199    }
11200}
11201impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> {
11202    fn deref_mut(&mut self) -> &mut Self::Target {
11203        &mut self.inner
11204    }
11205}
11206impl<'a> PresentInfoKHRBuilder<'a> {
11207    pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
11208        self.inner.wait_semaphore_count = wait_semaphores.len() as _;
11209        self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
11210        self
11211    }
11212    pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self {
11213        self.inner.swapchain_count = swapchains.len() as _;
11214        self.inner.p_swapchains = swapchains.as_ptr();
11215        self
11216    }
11217    pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self {
11218        self.inner.swapchain_count = image_indices.len() as _;
11219        self.inner.p_image_indices = image_indices.as_ptr();
11220        self
11221    }
11222    pub fn results(mut self, results: &'a mut [Result]) -> Self {
11223        self.inner.swapchain_count = results.len() as _;
11224        self.inner.p_results = results.as_mut_ptr();
11225        self
11226    }
11227    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11228    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11229    #[doc = r" valid extension structs can be pushed into the chain."]
11230    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11231    #[doc = r" chain will look like `A -> D -> B -> C`."]
11232    pub fn push_next<T: ExtendsPresentInfoKHR>(mut self, next: &'a mut T) -> Self {
11233        unsafe {
11234            let next_ptr = <*const T>::cast(next);
11235            let last_next = ptr_chain_iter(next).last().unwrap();
11236            (*last_next).p_next = self.inner.p_next as _;
11237            self.inner.p_next = next_ptr;
11238        }
11239        self
11240    }
11241    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11242    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11243    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11244    pub fn build(self) -> PresentInfoKHR {
11245        self.inner
11246    }
11247}
11248#[repr(C)]
11249#[derive(Copy, Clone)]
11250#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html>"]
11251pub struct DebugReportCallbackCreateInfoEXT {
11252    pub s_type: StructureType,
11253    pub p_next: *const c_void,
11254    pub flags: DebugReportFlagsEXT,
11255    pub pfn_callback: PFN_vkDebugReportCallbackEXT,
11256    pub p_user_data: *mut c_void,
11257}
11258#[cfg(feature = "debug")]
11259impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
11260    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
11261        fmt.debug_struct("DebugReportCallbackCreateInfoEXT")
11262            .field("s_type", &self.s_type)
11263            .field("p_next", &self.p_next)
11264            .field("flags", &self.flags)
11265            .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ())))
11266            .field("p_user_data", &self.p_user_data)
11267            .finish()
11268    }
11269}
11270impl ::std::default::Default for DebugReportCallbackCreateInfoEXT {
11271    fn default() -> Self {
11272        Self {
11273            s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
11274            p_next: ::std::ptr::null(),
11275            flags: DebugReportFlagsEXT::default(),
11276            pfn_callback: PFN_vkDebugReportCallbackEXT::default(),
11277            p_user_data: ::std::ptr::null_mut(),
11278        }
11279    }
11280}
11281impl DebugReportCallbackCreateInfoEXT {
11282    pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
11283        DebugReportCallbackCreateInfoEXTBuilder {
11284            inner: Self::default(),
11285            marker: ::std::marker::PhantomData,
11286        }
11287    }
11288}
11289#[repr(transparent)]
11290pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> {
11291    inner: DebugReportCallbackCreateInfoEXT,
11292    marker: ::std::marker::PhantomData<&'a ()>,
11293}
11294unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {}
11295unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {}
11296impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> {
11297    type Target = DebugReportCallbackCreateInfoEXT;
11298    fn deref(&self) -> &Self::Target {
11299        &self.inner
11300    }
11301}
11302impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> {
11303    fn deref_mut(&mut self) -> &mut Self::Target {
11304        &mut self.inner
11305    }
11306}
11307impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
11308    pub fn flags(mut self, flags: DebugReportFlagsEXT) -> Self {
11309        self.inner.flags = flags;
11310        self
11311    }
11312    pub fn pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self {
11313        self.inner.pfn_callback = pfn_callback;
11314        self
11315    }
11316    pub fn user_data(mut self, user_data: *mut c_void) -> Self {
11317        self.inner.p_user_data = user_data;
11318        self
11319    }
11320    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11321    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11322    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11323    pub fn build(self) -> DebugReportCallbackCreateInfoEXT {
11324        self.inner
11325    }
11326}
11327#[repr(C)]
11328#[cfg_attr(feature = "debug", derive(Debug))]
11329#[derive(Copy, Clone)]
11330#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFlagsEXT.html>"]
11331pub struct ValidationFlagsEXT {
11332    pub s_type: StructureType,
11333    pub p_next: *const c_void,
11334    pub disabled_validation_check_count: u32,
11335    pub p_disabled_validation_checks: *const ValidationCheckEXT,
11336}
11337impl ::std::default::Default for ValidationFlagsEXT {
11338    fn default() -> Self {
11339        Self {
11340            s_type: StructureType::VALIDATION_FLAGS_EXT,
11341            p_next: ::std::ptr::null(),
11342            disabled_validation_check_count: u32::default(),
11343            p_disabled_validation_checks: ::std::ptr::null(),
11344        }
11345    }
11346}
11347impl ValidationFlagsEXT {
11348    pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> {
11349        ValidationFlagsEXTBuilder {
11350            inner: Self::default(),
11351            marker: ::std::marker::PhantomData,
11352        }
11353    }
11354}
11355#[repr(transparent)]
11356pub struct ValidationFlagsEXTBuilder<'a> {
11357    inner: ValidationFlagsEXT,
11358    marker: ::std::marker::PhantomData<&'a ()>,
11359}
11360unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {}
11361unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {}
11362impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> {
11363    type Target = ValidationFlagsEXT;
11364    fn deref(&self) -> &Self::Target {
11365        &self.inner
11366    }
11367}
11368impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> {
11369    fn deref_mut(&mut self) -> &mut Self::Target {
11370        &mut self.inner
11371    }
11372}
11373impl<'a> ValidationFlagsEXTBuilder<'a> {
11374    pub fn disabled_validation_checks(
11375        mut self,
11376        disabled_validation_checks: &'a [ValidationCheckEXT],
11377    ) -> Self {
11378        self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _;
11379        self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr();
11380        self
11381    }
11382    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11383    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11384    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11385    pub fn build(self) -> ValidationFlagsEXT {
11386        self.inner
11387    }
11388}
11389#[repr(C)]
11390#[cfg_attr(feature = "debug", derive(Debug))]
11391#[derive(Copy, Clone)]
11392#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFeaturesEXT.html>"]
11393pub struct ValidationFeaturesEXT {
11394    pub s_type: StructureType,
11395    pub p_next: *const c_void,
11396    pub enabled_validation_feature_count: u32,
11397    pub p_enabled_validation_features: *const ValidationFeatureEnableEXT,
11398    pub disabled_validation_feature_count: u32,
11399    pub p_disabled_validation_features: *const ValidationFeatureDisableEXT,
11400}
11401impl ::std::default::Default for ValidationFeaturesEXT {
11402    fn default() -> Self {
11403        Self {
11404            s_type: StructureType::VALIDATION_FEATURES_EXT,
11405            p_next: ::std::ptr::null(),
11406            enabled_validation_feature_count: u32::default(),
11407            p_enabled_validation_features: ::std::ptr::null(),
11408            disabled_validation_feature_count: u32::default(),
11409            p_disabled_validation_features: ::std::ptr::null(),
11410        }
11411    }
11412}
11413impl ValidationFeaturesEXT {
11414    pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> {
11415        ValidationFeaturesEXTBuilder {
11416            inner: Self::default(),
11417            marker: ::std::marker::PhantomData,
11418        }
11419    }
11420}
11421#[repr(transparent)]
11422pub struct ValidationFeaturesEXTBuilder<'a> {
11423    inner: ValidationFeaturesEXT,
11424    marker: ::std::marker::PhantomData<&'a ()>,
11425}
11426unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {}
11427unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {}
11428impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> {
11429    type Target = ValidationFeaturesEXT;
11430    fn deref(&self) -> &Self::Target {
11431        &self.inner
11432    }
11433}
11434impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> {
11435    fn deref_mut(&mut self) -> &mut Self::Target {
11436        &mut self.inner
11437    }
11438}
11439impl<'a> ValidationFeaturesEXTBuilder<'a> {
11440    pub fn enabled_validation_features(
11441        mut self,
11442        enabled_validation_features: &'a [ValidationFeatureEnableEXT],
11443    ) -> Self {
11444        self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _;
11445        self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr();
11446        self
11447    }
11448    pub fn disabled_validation_features(
11449        mut self,
11450        disabled_validation_features: &'a [ValidationFeatureDisableEXT],
11451    ) -> Self {
11452        self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _;
11453        self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr();
11454        self
11455    }
11456    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11457    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11458    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11459    pub fn build(self) -> ValidationFeaturesEXT {
11460        self.inner
11461    }
11462}
11463#[repr(C)]
11464#[cfg_attr(feature = "debug", derive(Debug))]
11465#[derive(Copy, Clone)]
11466#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>"]
11467pub struct PipelineRasterizationStateRasterizationOrderAMD {
11468    pub s_type: StructureType,
11469    pub p_next: *const c_void,
11470    pub rasterization_order: RasterizationOrderAMD,
11471}
11472impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD {
11473    fn default() -> Self {
11474        Self {
11475            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
11476            p_next: ::std::ptr::null(),
11477            rasterization_order: RasterizationOrderAMD::default(),
11478        }
11479    }
11480}
11481impl PipelineRasterizationStateRasterizationOrderAMD {
11482    pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11483        PipelineRasterizationStateRasterizationOrderAMDBuilder {
11484            inner: Self::default(),
11485            marker: ::std::marker::PhantomData,
11486        }
11487    }
11488}
11489#[repr(transparent)]
11490pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11491    inner: PipelineRasterizationStateRasterizationOrderAMD,
11492    marker: ::std::marker::PhantomData<&'a ()>,
11493}
11494unsafe impl ExtendsPipelineRasterizationStateCreateInfo
11495    for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_>
11496{
11497}
11498unsafe impl ExtendsPipelineRasterizationStateCreateInfo
11499    for PipelineRasterizationStateRasterizationOrderAMD
11500{
11501}
11502impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11503    type Target = PipelineRasterizationStateRasterizationOrderAMD;
11504    fn deref(&self) -> &Self::Target {
11505        &self.inner
11506    }
11507}
11508impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11509    fn deref_mut(&mut self) -> &mut Self::Target {
11510        &mut self.inner
11511    }
11512}
11513impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
11514    pub fn rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self {
11515        self.inner.rasterization_order = rasterization_order;
11516        self
11517    }
11518    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11519    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11520    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11521    pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD {
11522        self.inner
11523    }
11524}
11525#[repr(C)]
11526#[cfg_attr(feature = "debug", derive(Debug))]
11527#[derive(Copy, Clone)]
11528#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html>"]
11529pub struct DebugMarkerObjectNameInfoEXT {
11530    pub s_type: StructureType,
11531    pub p_next: *const c_void,
11532    pub object_type: DebugReportObjectTypeEXT,
11533    pub object: u64,
11534    pub p_object_name: *const c_char,
11535}
11536impl ::std::default::Default for DebugMarkerObjectNameInfoEXT {
11537    fn default() -> Self {
11538        Self {
11539            s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
11540            p_next: ::std::ptr::null(),
11541            object_type: DebugReportObjectTypeEXT::default(),
11542            object: u64::default(),
11543            p_object_name: ::std::ptr::null(),
11544        }
11545    }
11546}
11547impl DebugMarkerObjectNameInfoEXT {
11548    pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
11549        DebugMarkerObjectNameInfoEXTBuilder {
11550            inner: Self::default(),
11551            marker: ::std::marker::PhantomData,
11552        }
11553    }
11554}
11555#[repr(transparent)]
11556pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> {
11557    inner: DebugMarkerObjectNameInfoEXT,
11558    marker: ::std::marker::PhantomData<&'a ()>,
11559}
11560impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> {
11561    type Target = DebugMarkerObjectNameInfoEXT;
11562    fn deref(&self) -> &Self::Target {
11563        &self.inner
11564    }
11565}
11566impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> {
11567    fn deref_mut(&mut self) -> &mut Self::Target {
11568        &mut self.inner
11569    }
11570}
11571impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
11572    pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
11573        self.inner.object_type = object_type;
11574        self
11575    }
11576    pub fn object(mut self, object: u64) -> Self {
11577        self.inner.object = object;
11578        self
11579    }
11580    pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
11581        self.inner.p_object_name = object_name.as_ptr();
11582        self
11583    }
11584    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11585    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11586    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11587    pub fn build(self) -> DebugMarkerObjectNameInfoEXT {
11588        self.inner
11589    }
11590}
11591#[repr(C)]
11592#[cfg_attr(feature = "debug", derive(Debug))]
11593#[derive(Copy, Clone)]
11594#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html>"]
11595pub struct DebugMarkerObjectTagInfoEXT {
11596    pub s_type: StructureType,
11597    pub p_next: *const c_void,
11598    pub object_type: DebugReportObjectTypeEXT,
11599    pub object: u64,
11600    pub tag_name: u64,
11601    pub tag_size: usize,
11602    pub p_tag: *const c_void,
11603}
11604impl ::std::default::Default for DebugMarkerObjectTagInfoEXT {
11605    fn default() -> Self {
11606        Self {
11607            s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
11608            p_next: ::std::ptr::null(),
11609            object_type: DebugReportObjectTypeEXT::default(),
11610            object: u64::default(),
11611            tag_name: u64::default(),
11612            tag_size: usize::default(),
11613            p_tag: ::std::ptr::null(),
11614        }
11615    }
11616}
11617impl DebugMarkerObjectTagInfoEXT {
11618    pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
11619        DebugMarkerObjectTagInfoEXTBuilder {
11620            inner: Self::default(),
11621            marker: ::std::marker::PhantomData,
11622        }
11623    }
11624}
11625#[repr(transparent)]
11626pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> {
11627    inner: DebugMarkerObjectTagInfoEXT,
11628    marker: ::std::marker::PhantomData<&'a ()>,
11629}
11630impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> {
11631    type Target = DebugMarkerObjectTagInfoEXT;
11632    fn deref(&self) -> &Self::Target {
11633        &self.inner
11634    }
11635}
11636impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> {
11637    fn deref_mut(&mut self) -> &mut Self::Target {
11638        &mut self.inner
11639    }
11640}
11641impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
11642    pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
11643        self.inner.object_type = object_type;
11644        self
11645    }
11646    pub fn object(mut self, object: u64) -> Self {
11647        self.inner.object = object;
11648        self
11649    }
11650    pub fn tag_name(mut self, tag_name: u64) -> Self {
11651        self.inner.tag_name = tag_name;
11652        self
11653    }
11654    pub fn tag(mut self, tag: &'a [u8]) -> Self {
11655        self.inner.tag_size = tag.len();
11656        self.inner.p_tag = tag.as_ptr() as *const c_void;
11657        self
11658    }
11659    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11660    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11661    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11662    pub fn build(self) -> DebugMarkerObjectTagInfoEXT {
11663        self.inner
11664    }
11665}
11666#[repr(C)]
11667#[cfg_attr(feature = "debug", derive(Debug))]
11668#[derive(Copy, Clone)]
11669#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html>"]
11670pub struct DebugMarkerMarkerInfoEXT {
11671    pub s_type: StructureType,
11672    pub p_next: *const c_void,
11673    pub p_marker_name: *const c_char,
11674    pub color: [f32; 4],
11675}
11676impl ::std::default::Default for DebugMarkerMarkerInfoEXT {
11677    fn default() -> Self {
11678        Self {
11679            s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT,
11680            p_next: ::std::ptr::null(),
11681            p_marker_name: ::std::ptr::null(),
11682            color: unsafe { ::std::mem::zeroed() },
11683        }
11684    }
11685}
11686impl DebugMarkerMarkerInfoEXT {
11687    pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> {
11688        DebugMarkerMarkerInfoEXTBuilder {
11689            inner: Self::default(),
11690            marker: ::std::marker::PhantomData,
11691        }
11692    }
11693}
11694#[repr(transparent)]
11695pub struct DebugMarkerMarkerInfoEXTBuilder<'a> {
11696    inner: DebugMarkerMarkerInfoEXT,
11697    marker: ::std::marker::PhantomData<&'a ()>,
11698}
11699impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> {
11700    type Target = DebugMarkerMarkerInfoEXT;
11701    fn deref(&self) -> &Self::Target {
11702        &self.inner
11703    }
11704}
11705impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> {
11706    fn deref_mut(&mut self) -> &mut Self::Target {
11707        &mut self.inner
11708    }
11709}
11710impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
11711    pub fn marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self {
11712        self.inner.p_marker_name = marker_name.as_ptr();
11713        self
11714    }
11715    pub fn color(mut self, color: [f32; 4]) -> Self {
11716        self.inner.color = color;
11717        self
11718    }
11719    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11720    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11721    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11722    pub fn build(self) -> DebugMarkerMarkerInfoEXT {
11723        self.inner
11724    }
11725}
11726#[repr(C)]
11727#[cfg_attr(feature = "debug", derive(Debug))]
11728#[derive(Copy, Clone)]
11729#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html>"]
11730pub struct DedicatedAllocationImageCreateInfoNV {
11731    pub s_type: StructureType,
11732    pub p_next: *const c_void,
11733    pub dedicated_allocation: Bool32,
11734}
11735impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV {
11736    fn default() -> Self {
11737        Self {
11738            s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
11739            p_next: ::std::ptr::null(),
11740            dedicated_allocation: Bool32::default(),
11741        }
11742    }
11743}
11744impl DedicatedAllocationImageCreateInfoNV {
11745    pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11746        DedicatedAllocationImageCreateInfoNVBuilder {
11747            inner: Self::default(),
11748            marker: ::std::marker::PhantomData,
11749        }
11750    }
11751}
11752#[repr(transparent)]
11753pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11754    inner: DedicatedAllocationImageCreateInfoNV,
11755    marker: ::std::marker::PhantomData<&'a ()>,
11756}
11757unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {}
11758unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {}
11759impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11760    type Target = DedicatedAllocationImageCreateInfoNV;
11761    fn deref(&self) -> &Self::Target {
11762        &self.inner
11763    }
11764}
11765impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11766    fn deref_mut(&mut self) -> &mut Self::Target {
11767        &mut self.inner
11768    }
11769}
11770impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
11771    pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
11772        self.inner.dedicated_allocation = dedicated_allocation.into();
11773        self
11774    }
11775    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11776    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11777    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11778    pub fn build(self) -> DedicatedAllocationImageCreateInfoNV {
11779        self.inner
11780    }
11781}
11782#[repr(C)]
11783#[cfg_attr(feature = "debug", derive(Debug))]
11784#[derive(Copy, Clone)]
11785#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>"]
11786pub struct DedicatedAllocationBufferCreateInfoNV {
11787    pub s_type: StructureType,
11788    pub p_next: *const c_void,
11789    pub dedicated_allocation: Bool32,
11790}
11791impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV {
11792    fn default() -> Self {
11793        Self {
11794            s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
11795            p_next: ::std::ptr::null(),
11796            dedicated_allocation: Bool32::default(),
11797        }
11798    }
11799}
11800impl DedicatedAllocationBufferCreateInfoNV {
11801    pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11802        DedicatedAllocationBufferCreateInfoNVBuilder {
11803            inner: Self::default(),
11804            marker: ::std::marker::PhantomData,
11805        }
11806    }
11807}
11808#[repr(transparent)]
11809pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11810    inner: DedicatedAllocationBufferCreateInfoNV,
11811    marker: ::std::marker::PhantomData<&'a ()>,
11812}
11813unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {}
11814unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {}
11815impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11816    type Target = DedicatedAllocationBufferCreateInfoNV;
11817    fn deref(&self) -> &Self::Target {
11818        &self.inner
11819    }
11820}
11821impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11822    fn deref_mut(&mut self) -> &mut Self::Target {
11823        &mut self.inner
11824    }
11825}
11826impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
11827    pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
11828        self.inner.dedicated_allocation = dedicated_allocation.into();
11829        self
11830    }
11831    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11832    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11833    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11834    pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV {
11835        self.inner
11836    }
11837}
11838#[repr(C)]
11839#[cfg_attr(feature = "debug", derive(Debug))]
11840#[derive(Copy, Clone)]
11841#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>"]
11842pub struct DedicatedAllocationMemoryAllocateInfoNV {
11843    pub s_type: StructureType,
11844    pub p_next: *const c_void,
11845    pub image: Image,
11846    pub buffer: Buffer,
11847}
11848impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV {
11849    fn default() -> Self {
11850        Self {
11851            s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
11852            p_next: ::std::ptr::null(),
11853            image: Image::default(),
11854            buffer: Buffer::default(),
11855        }
11856    }
11857}
11858impl DedicatedAllocationMemoryAllocateInfoNV {
11859    pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11860        DedicatedAllocationMemoryAllocateInfoNVBuilder {
11861            inner: Self::default(),
11862            marker: ::std::marker::PhantomData,
11863        }
11864    }
11865}
11866#[repr(transparent)]
11867pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11868    inner: DedicatedAllocationMemoryAllocateInfoNV,
11869    marker: ::std::marker::PhantomData<&'a ()>,
11870}
11871unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {}
11872unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {}
11873impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11874    type Target = DedicatedAllocationMemoryAllocateInfoNV;
11875    fn deref(&self) -> &Self::Target {
11876        &self.inner
11877    }
11878}
11879impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11880    fn deref_mut(&mut self) -> &mut Self::Target {
11881        &mut self.inner
11882    }
11883}
11884impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
11885    pub fn image(mut self, image: Image) -> Self {
11886        self.inner.image = image;
11887        self
11888    }
11889    pub fn buffer(mut self, buffer: Buffer) -> Self {
11890        self.inner.buffer = buffer;
11891        self
11892    }
11893    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11894    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11895    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11896    pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV {
11897        self.inner
11898    }
11899}
11900#[repr(C)]
11901#[cfg_attr(feature = "debug", derive(Debug))]
11902#[derive(Copy, Clone, Default)]
11903#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatPropertiesNV.html>"]
11904pub struct ExternalImageFormatPropertiesNV {
11905    pub image_format_properties: ImageFormatProperties,
11906    pub external_memory_features: ExternalMemoryFeatureFlagsNV,
11907    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
11908    pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
11909}
11910impl ExternalImageFormatPropertiesNV {
11911    pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> {
11912        ExternalImageFormatPropertiesNVBuilder {
11913            inner: Self::default(),
11914            marker: ::std::marker::PhantomData,
11915        }
11916    }
11917}
11918#[repr(transparent)]
11919pub struct ExternalImageFormatPropertiesNVBuilder<'a> {
11920    inner: ExternalImageFormatPropertiesNV,
11921    marker: ::std::marker::PhantomData<&'a ()>,
11922}
11923impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> {
11924    type Target = ExternalImageFormatPropertiesNV;
11925    fn deref(&self) -> &Self::Target {
11926        &self.inner
11927    }
11928}
11929impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> {
11930    fn deref_mut(&mut self) -> &mut Self::Target {
11931        &mut self.inner
11932    }
11933}
11934impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
11935    pub fn image_format_properties(
11936        mut self,
11937        image_format_properties: ImageFormatProperties,
11938    ) -> Self {
11939        self.inner.image_format_properties = image_format_properties;
11940        self
11941    }
11942    pub fn external_memory_features(
11943        mut self,
11944        external_memory_features: ExternalMemoryFeatureFlagsNV,
11945    ) -> Self {
11946        self.inner.external_memory_features = external_memory_features;
11947        self
11948    }
11949    pub fn export_from_imported_handle_types(
11950        mut self,
11951        export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
11952    ) -> Self {
11953        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
11954        self
11955    }
11956    pub fn compatible_handle_types(
11957        mut self,
11958        compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
11959    ) -> Self {
11960        self.inner.compatible_handle_types = compatible_handle_types;
11961        self
11962    }
11963    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11964    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11965    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
11966    pub fn build(self) -> ExternalImageFormatPropertiesNV {
11967        self.inner
11968    }
11969}
11970#[repr(C)]
11971#[cfg_attr(feature = "debug", derive(Debug))]
11972#[derive(Copy, Clone)]
11973#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html>"]
11974pub struct ExternalMemoryImageCreateInfoNV {
11975    pub s_type: StructureType,
11976    pub p_next: *const c_void,
11977    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
11978}
11979impl ::std::default::Default for ExternalMemoryImageCreateInfoNV {
11980    fn default() -> Self {
11981        Self {
11982            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
11983            p_next: ::std::ptr::null(),
11984            handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
11985        }
11986    }
11987}
11988impl ExternalMemoryImageCreateInfoNV {
11989    pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
11990        ExternalMemoryImageCreateInfoNVBuilder {
11991            inner: Self::default(),
11992            marker: ::std::marker::PhantomData,
11993        }
11994    }
11995}
11996#[repr(transparent)]
11997pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> {
11998    inner: ExternalMemoryImageCreateInfoNV,
11999    marker: ::std::marker::PhantomData<&'a ()>,
12000}
12001unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {}
12002unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {}
12003impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> {
12004    type Target = ExternalMemoryImageCreateInfoNV;
12005    fn deref(&self) -> &Self::Target {
12006        &self.inner
12007    }
12008}
12009impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> {
12010    fn deref_mut(&mut self) -> &mut Self::Target {
12011        &mut self.inner
12012    }
12013}
12014impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
12015    pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
12016        self.inner.handle_types = handle_types;
12017        self
12018    }
12019    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12020    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12021    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12022    pub fn build(self) -> ExternalMemoryImageCreateInfoNV {
12023        self.inner
12024    }
12025}
12026#[repr(C)]
12027#[cfg_attr(feature = "debug", derive(Debug))]
12028#[derive(Copy, Clone)]
12029#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfoNV.html>"]
12030pub struct ExportMemoryAllocateInfoNV {
12031    pub s_type: StructureType,
12032    pub p_next: *const c_void,
12033    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
12034}
12035impl ::std::default::Default for ExportMemoryAllocateInfoNV {
12036    fn default() -> Self {
12037        Self {
12038            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV,
12039            p_next: ::std::ptr::null(),
12040            handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
12041        }
12042    }
12043}
12044impl ExportMemoryAllocateInfoNV {
12045    pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> {
12046        ExportMemoryAllocateInfoNVBuilder {
12047            inner: Self::default(),
12048            marker: ::std::marker::PhantomData,
12049        }
12050    }
12051}
12052#[repr(transparent)]
12053pub struct ExportMemoryAllocateInfoNVBuilder<'a> {
12054    inner: ExportMemoryAllocateInfoNV,
12055    marker: ::std::marker::PhantomData<&'a ()>,
12056}
12057unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {}
12058unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {}
12059impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> {
12060    type Target = ExportMemoryAllocateInfoNV;
12061    fn deref(&self) -> &Self::Target {
12062        &self.inner
12063    }
12064}
12065impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> {
12066    fn deref_mut(&mut self) -> &mut Self::Target {
12067        &mut self.inner
12068    }
12069}
12070impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
12071    pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
12072        self.inner.handle_types = handle_types;
12073        self
12074    }
12075    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12076    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12077    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12078    pub fn build(self) -> ExportMemoryAllocateInfoNV {
12079        self.inner
12080    }
12081}
12082#[repr(C)]
12083#[cfg_attr(feature = "debug", derive(Debug))]
12084#[derive(Copy, Clone)]
12085#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html>"]
12086pub struct ImportMemoryWin32HandleInfoNV {
12087    pub s_type: StructureType,
12088    pub p_next: *const c_void,
12089    pub handle_type: ExternalMemoryHandleTypeFlagsNV,
12090    pub handle: HANDLE,
12091}
12092impl ::std::default::Default for ImportMemoryWin32HandleInfoNV {
12093    fn default() -> Self {
12094        Self {
12095            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
12096            p_next: ::std::ptr::null(),
12097            handle_type: ExternalMemoryHandleTypeFlagsNV::default(),
12098            handle: unsafe { ::std::mem::zeroed() },
12099        }
12100    }
12101}
12102impl ImportMemoryWin32HandleInfoNV {
12103    pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
12104        ImportMemoryWin32HandleInfoNVBuilder {
12105            inner: Self::default(),
12106            marker: ::std::marker::PhantomData,
12107        }
12108    }
12109}
12110#[repr(transparent)]
12111pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> {
12112    inner: ImportMemoryWin32HandleInfoNV,
12113    marker: ::std::marker::PhantomData<&'a ()>,
12114}
12115unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {}
12116unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {}
12117impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> {
12118    type Target = ImportMemoryWin32HandleInfoNV;
12119    fn deref(&self) -> &Self::Target {
12120        &self.inner
12121    }
12122}
12123impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> {
12124    fn deref_mut(&mut self) -> &mut Self::Target {
12125        &mut self.inner
12126    }
12127}
12128impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
12129    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self {
12130        self.inner.handle_type = handle_type;
12131        self
12132    }
12133    pub fn handle(mut self, handle: HANDLE) -> Self {
12134        self.inner.handle = handle;
12135        self
12136    }
12137    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12138    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12139    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12140    pub fn build(self) -> ImportMemoryWin32HandleInfoNV {
12141        self.inner
12142    }
12143}
12144#[repr(C)]
12145#[cfg_attr(feature = "debug", derive(Debug))]
12146#[derive(Copy, Clone)]
12147#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html>"]
12148pub struct ExportMemoryWin32HandleInfoNV {
12149    pub s_type: StructureType,
12150    pub p_next: *const c_void,
12151    pub p_attributes: *const SECURITY_ATTRIBUTES,
12152    pub dw_access: DWORD,
12153}
12154impl ::std::default::Default for ExportMemoryWin32HandleInfoNV {
12155    fn default() -> Self {
12156        Self {
12157            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
12158            p_next: ::std::ptr::null(),
12159            p_attributes: ::std::ptr::null(),
12160            dw_access: DWORD::default(),
12161        }
12162    }
12163}
12164impl ExportMemoryWin32HandleInfoNV {
12165    pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
12166        ExportMemoryWin32HandleInfoNVBuilder {
12167            inner: Self::default(),
12168            marker: ::std::marker::PhantomData,
12169        }
12170    }
12171}
12172#[repr(transparent)]
12173pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> {
12174    inner: ExportMemoryWin32HandleInfoNV,
12175    marker: ::std::marker::PhantomData<&'a ()>,
12176}
12177unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {}
12178unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {}
12179impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> {
12180    type Target = ExportMemoryWin32HandleInfoNV;
12181    fn deref(&self) -> &Self::Target {
12182        &self.inner
12183    }
12184}
12185impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> {
12186    fn deref_mut(&mut self) -> &mut Self::Target {
12187        &mut self.inner
12188    }
12189}
12190impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
12191    pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
12192        self.inner.p_attributes = attributes;
12193        self
12194    }
12195    pub fn dw_access(mut self, dw_access: DWORD) -> Self {
12196        self.inner.dw_access = dw_access;
12197        self
12198    }
12199    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12200    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12201    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12202    pub fn build(self) -> ExportMemoryWin32HandleInfoNV {
12203        self.inner
12204    }
12205}
12206#[repr(C)]
12207#[cfg_attr(feature = "debug", derive(Debug))]
12208#[derive(Copy, Clone)]
12209#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>"]
12210pub struct Win32KeyedMutexAcquireReleaseInfoNV {
12211    pub s_type: StructureType,
12212    pub p_next: *const c_void,
12213    pub acquire_count: u32,
12214    pub p_acquire_syncs: *const DeviceMemory,
12215    pub p_acquire_keys: *const u64,
12216    pub p_acquire_timeout_milliseconds: *const u32,
12217    pub release_count: u32,
12218    pub p_release_syncs: *const DeviceMemory,
12219    pub p_release_keys: *const u64,
12220}
12221impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV {
12222    fn default() -> Self {
12223        Self {
12224            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
12225            p_next: ::std::ptr::null(),
12226            acquire_count: u32::default(),
12227            p_acquire_syncs: ::std::ptr::null(),
12228            p_acquire_keys: ::std::ptr::null(),
12229            p_acquire_timeout_milliseconds: ::std::ptr::null(),
12230            release_count: u32::default(),
12231            p_release_syncs: ::std::ptr::null(),
12232            p_release_keys: ::std::ptr::null(),
12233        }
12234    }
12235}
12236impl Win32KeyedMutexAcquireReleaseInfoNV {
12237    pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12238        Win32KeyedMutexAcquireReleaseInfoNVBuilder {
12239            inner: Self::default(),
12240            marker: ::std::marker::PhantomData,
12241        }
12242    }
12243}
12244#[repr(transparent)]
12245pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12246    inner: Win32KeyedMutexAcquireReleaseInfoNV,
12247    marker: ::std::marker::PhantomData<&'a ()>,
12248}
12249unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
12250unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {}
12251unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
12252unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV {}
12253impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12254    type Target = Win32KeyedMutexAcquireReleaseInfoNV;
12255    fn deref(&self) -> &Self::Target {
12256        &self.inner
12257    }
12258}
12259impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12260    fn deref_mut(&mut self) -> &mut Self::Target {
12261        &mut self.inner
12262    }
12263}
12264impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
12265    pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
12266        self.inner.acquire_count = acquire_syncs.len() as _;
12267        self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
12268        self
12269    }
12270    pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
12271        self.inner.acquire_count = acquire_keys.len() as _;
12272        self.inner.p_acquire_keys = acquire_keys.as_ptr();
12273        self
12274    }
12275    pub fn acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self {
12276        self.inner.acquire_count = acquire_timeout_milliseconds.len() as _;
12277        self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr();
12278        self
12279    }
12280    pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
12281        self.inner.release_count = release_syncs.len() as _;
12282        self.inner.p_release_syncs = release_syncs.as_ptr();
12283        self
12284    }
12285    pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
12286        self.inner.release_count = release_keys.len() as _;
12287        self.inner.p_release_keys = release_keys.as_ptr();
12288        self
12289    }
12290    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12291    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12292    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12293    pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV {
12294        self.inner
12295    }
12296}
12297#[repr(C)]
12298#[cfg_attr(feature = "debug", derive(Debug))]
12299#[derive(Copy, Clone)]
12300#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>"]
12301pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12302    pub s_type: StructureType,
12303    pub p_next: *mut c_void,
12304    pub device_generated_commands: Bool32,
12305}
12306impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12307    fn default() -> Self {
12308        Self {
12309            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
12310            p_next: ::std::ptr::null_mut(),
12311            device_generated_commands: Bool32::default(),
12312        }
12313    }
12314}
12315impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12316    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12317        PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder {
12318            inner: Self::default(),
12319            marker: ::std::marker::PhantomData,
12320        }
12321    }
12322}
12323#[repr(transparent)]
12324pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12325    inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
12326    marker: ::std::marker::PhantomData<&'a ()>,
12327}
12328unsafe impl ExtendsPhysicalDeviceFeatures2
12329    for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_>
12330{
12331}
12332unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
12333unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {}
12334unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
12335impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12336    type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
12337    fn deref(&self) -> &Self::Target {
12338        &self.inner
12339    }
12340}
12341impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12342    fn deref_mut(&mut self) -> &mut Self::Target {
12343        &mut self.inner
12344    }
12345}
12346impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
12347    pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self {
12348        self.inner.device_generated_commands = device_generated_commands.into();
12349        self
12350    }
12351    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12352    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12353    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12354    pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
12355        self.inner
12356    }
12357}
12358#[repr(C)]
12359#[cfg_attr(feature = "debug", derive(Debug))]
12360#[derive(Copy, Clone)]
12361#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevicePrivateDataCreateInfo.html>"]
12362pub struct DevicePrivateDataCreateInfo {
12363    pub s_type: StructureType,
12364    pub p_next: *const c_void,
12365    pub private_data_slot_request_count: u32,
12366}
12367impl ::std::default::Default for DevicePrivateDataCreateInfo {
12368    fn default() -> Self {
12369        Self {
12370            s_type: StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO,
12371            p_next: ::std::ptr::null(),
12372            private_data_slot_request_count: u32::default(),
12373        }
12374    }
12375}
12376impl DevicePrivateDataCreateInfo {
12377    pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> {
12378        DevicePrivateDataCreateInfoBuilder {
12379            inner: Self::default(),
12380            marker: ::std::marker::PhantomData,
12381        }
12382    }
12383}
12384#[repr(transparent)]
12385pub struct DevicePrivateDataCreateInfoBuilder<'a> {
12386    inner: DevicePrivateDataCreateInfo,
12387    marker: ::std::marker::PhantomData<&'a ()>,
12388}
12389unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoBuilder<'_> {}
12390unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo {}
12391impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> {
12392    type Target = DevicePrivateDataCreateInfo;
12393    fn deref(&self) -> &Self::Target {
12394        &self.inner
12395    }
12396}
12397impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> {
12398    fn deref_mut(&mut self) -> &mut Self::Target {
12399        &mut self.inner
12400    }
12401}
12402impl<'a> DevicePrivateDataCreateInfoBuilder<'a> {
12403    pub fn private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self {
12404        self.inner.private_data_slot_request_count = private_data_slot_request_count;
12405        self
12406    }
12407    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12408    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12409    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12410    pub fn build(self) -> DevicePrivateDataCreateInfo {
12411        self.inner
12412    }
12413}
12414#[repr(C)]
12415#[cfg_attr(feature = "debug", derive(Debug))]
12416#[derive(Copy, Clone)]
12417#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateInfo.html>"]
12418pub struct PrivateDataSlotCreateInfo {
12419    pub s_type: StructureType,
12420    pub p_next: *const c_void,
12421    pub flags: PrivateDataSlotCreateFlags,
12422}
12423impl ::std::default::Default for PrivateDataSlotCreateInfo {
12424    fn default() -> Self {
12425        Self {
12426            s_type: StructureType::PRIVATE_DATA_SLOT_CREATE_INFO,
12427            p_next: ::std::ptr::null(),
12428            flags: PrivateDataSlotCreateFlags::default(),
12429        }
12430    }
12431}
12432impl PrivateDataSlotCreateInfo {
12433    pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> {
12434        PrivateDataSlotCreateInfoBuilder {
12435            inner: Self::default(),
12436            marker: ::std::marker::PhantomData,
12437        }
12438    }
12439}
12440#[repr(transparent)]
12441pub struct PrivateDataSlotCreateInfoBuilder<'a> {
12442    inner: PrivateDataSlotCreateInfo,
12443    marker: ::std::marker::PhantomData<&'a ()>,
12444}
12445impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> {
12446    type Target = PrivateDataSlotCreateInfo;
12447    fn deref(&self) -> &Self::Target {
12448        &self.inner
12449    }
12450}
12451impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> {
12452    fn deref_mut(&mut self) -> &mut Self::Target {
12453        &mut self.inner
12454    }
12455}
12456impl<'a> PrivateDataSlotCreateInfoBuilder<'a> {
12457    pub fn flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self {
12458        self.inner.flags = flags;
12459        self
12460    }
12461    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12462    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12463    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12464    pub fn build(self) -> PrivateDataSlotCreateInfo {
12465        self.inner
12466    }
12467}
12468#[repr(C)]
12469#[cfg_attr(feature = "debug", derive(Debug))]
12470#[derive(Copy, Clone)]
12471#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrivateDataFeatures.html>"]
12472pub struct PhysicalDevicePrivateDataFeatures {
12473    pub s_type: StructureType,
12474    pub p_next: *mut c_void,
12475    pub private_data: Bool32,
12476}
12477impl ::std::default::Default for PhysicalDevicePrivateDataFeatures {
12478    fn default() -> Self {
12479        Self {
12480            s_type: StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES,
12481            p_next: ::std::ptr::null_mut(),
12482            private_data: Bool32::default(),
12483        }
12484    }
12485}
12486impl PhysicalDevicePrivateDataFeatures {
12487    pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12488        PhysicalDevicePrivateDataFeaturesBuilder {
12489            inner: Self::default(),
12490            marker: ::std::marker::PhantomData,
12491        }
12492    }
12493}
12494#[repr(transparent)]
12495pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12496    inner: PhysicalDevicePrivateDataFeatures,
12497    marker: ::std::marker::PhantomData<&'a ()>,
12498}
12499unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
12500unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures {}
12501unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
12502unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures {}
12503impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12504    type Target = PhysicalDevicePrivateDataFeatures;
12505    fn deref(&self) -> &Self::Target {
12506        &self.inner
12507    }
12508}
12509impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12510    fn deref_mut(&mut self) -> &mut Self::Target {
12511        &mut self.inner
12512    }
12513}
12514impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
12515    pub fn private_data(mut self, private_data: bool) -> Self {
12516        self.inner.private_data = private_data.into();
12517        self
12518    }
12519    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12520    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12521    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12522    pub fn build(self) -> PhysicalDevicePrivateDataFeatures {
12523        self.inner
12524    }
12525}
12526#[repr(C)]
12527#[cfg_attr(feature = "debug", derive(Debug))]
12528#[derive(Copy, Clone)]
12529#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>"]
12530pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12531    pub s_type: StructureType,
12532    pub p_next: *mut c_void,
12533    pub max_graphics_shader_group_count: u32,
12534    pub max_indirect_sequence_count: u32,
12535    pub max_indirect_commands_token_count: u32,
12536    pub max_indirect_commands_stream_count: u32,
12537    pub max_indirect_commands_token_offset: u32,
12538    pub max_indirect_commands_stream_stride: u32,
12539    pub min_sequences_count_buffer_offset_alignment: u32,
12540    pub min_sequences_index_buffer_offset_alignment: u32,
12541    pub min_indirect_commands_buffer_offset_alignment: u32,
12542}
12543impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12544    fn default() -> Self {
12545        Self {
12546            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
12547            p_next: ::std::ptr::null_mut(),
12548            max_graphics_shader_group_count: u32::default(),
12549            max_indirect_sequence_count: u32::default(),
12550            max_indirect_commands_token_count: u32::default(),
12551            max_indirect_commands_stream_count: u32::default(),
12552            max_indirect_commands_token_offset: u32::default(),
12553            max_indirect_commands_stream_stride: u32::default(),
12554            min_sequences_count_buffer_offset_alignment: u32::default(),
12555            min_sequences_index_buffer_offset_alignment: u32::default(),
12556            min_indirect_commands_buffer_offset_alignment: u32::default(),
12557        }
12558    }
12559}
12560impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12561    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12562        PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder {
12563            inner: Self::default(),
12564            marker: ::std::marker::PhantomData,
12565        }
12566    }
12567}
12568#[repr(transparent)]
12569pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12570    inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
12571    marker: ::std::marker::PhantomData<&'a ()>,
12572}
12573unsafe impl ExtendsPhysicalDeviceProperties2
12574    for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_>
12575{
12576}
12577unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {}
12578impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12579    type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
12580    fn deref(&self) -> &Self::Target {
12581        &self.inner
12582    }
12583}
12584impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12585    fn deref_mut(&mut self) -> &mut Self::Target {
12586        &mut self.inner
12587    }
12588}
12589impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
12590    pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self {
12591        self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count;
12592        self
12593    }
12594    pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self {
12595        self.inner.max_indirect_sequence_count = max_indirect_sequence_count;
12596        self
12597    }
12598    pub fn max_indirect_commands_token_count(
12599        mut self,
12600        max_indirect_commands_token_count: u32,
12601    ) -> Self {
12602        self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count;
12603        self
12604    }
12605    pub fn max_indirect_commands_stream_count(
12606        mut self,
12607        max_indirect_commands_stream_count: u32,
12608    ) -> Self {
12609        self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count;
12610        self
12611    }
12612    pub fn max_indirect_commands_token_offset(
12613        mut self,
12614        max_indirect_commands_token_offset: u32,
12615    ) -> Self {
12616        self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset;
12617        self
12618    }
12619    pub fn max_indirect_commands_stream_stride(
12620        mut self,
12621        max_indirect_commands_stream_stride: u32,
12622    ) -> Self {
12623        self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride;
12624        self
12625    }
12626    pub fn min_sequences_count_buffer_offset_alignment(
12627        mut self,
12628        min_sequences_count_buffer_offset_alignment: u32,
12629    ) -> Self {
12630        self.inner.min_sequences_count_buffer_offset_alignment =
12631            min_sequences_count_buffer_offset_alignment;
12632        self
12633    }
12634    pub fn min_sequences_index_buffer_offset_alignment(
12635        mut self,
12636        min_sequences_index_buffer_offset_alignment: u32,
12637    ) -> Self {
12638        self.inner.min_sequences_index_buffer_offset_alignment =
12639            min_sequences_index_buffer_offset_alignment;
12640        self
12641    }
12642    pub fn min_indirect_commands_buffer_offset_alignment(
12643        mut self,
12644        min_indirect_commands_buffer_offset_alignment: u32,
12645    ) -> Self {
12646        self.inner.min_indirect_commands_buffer_offset_alignment =
12647            min_indirect_commands_buffer_offset_alignment;
12648        self
12649    }
12650    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12651    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12652    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12653    pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
12654        self.inner
12655    }
12656}
12657#[repr(C)]
12658#[cfg_attr(feature = "debug", derive(Debug))]
12659#[derive(Copy, Clone)]
12660#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html>"]
12661pub struct PhysicalDeviceMultiDrawPropertiesEXT {
12662    pub s_type: StructureType,
12663    pub p_next: *mut c_void,
12664    pub max_multi_draw_count: u32,
12665}
12666impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT {
12667    fn default() -> Self {
12668        Self {
12669            s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT,
12670            p_next: ::std::ptr::null_mut(),
12671            max_multi_draw_count: u32::default(),
12672        }
12673    }
12674}
12675impl PhysicalDeviceMultiDrawPropertiesEXT {
12676    pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12677        PhysicalDeviceMultiDrawPropertiesEXTBuilder {
12678            inner: Self::default(),
12679            marker: ::std::marker::PhantomData,
12680        }
12681    }
12682}
12683#[repr(transparent)]
12684pub struct PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12685    inner: PhysicalDeviceMultiDrawPropertiesEXT,
12686    marker: ::std::marker::PhantomData<&'a ()>,
12687}
12688unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'_> {}
12689unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT {}
12690impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12691    type Target = PhysicalDeviceMultiDrawPropertiesEXT;
12692    fn deref(&self) -> &Self::Target {
12693        &self.inner
12694    }
12695}
12696impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12697    fn deref_mut(&mut self) -> &mut Self::Target {
12698        &mut self.inner
12699    }
12700}
12701impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
12702    pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self {
12703        self.inner.max_multi_draw_count = max_multi_draw_count;
12704        self
12705    }
12706    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12707    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12708    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12709    pub fn build(self) -> PhysicalDeviceMultiDrawPropertiesEXT {
12710        self.inner
12711    }
12712}
12713#[repr(C)]
12714#[cfg_attr(feature = "debug", derive(Debug))]
12715#[derive(Copy, Clone)]
12716#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html>"]
12717pub struct GraphicsShaderGroupCreateInfoNV {
12718    pub s_type: StructureType,
12719    pub p_next: *const c_void,
12720    pub stage_count: u32,
12721    pub p_stages: *const PipelineShaderStageCreateInfo,
12722    pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
12723    pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
12724}
12725impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV {
12726    fn default() -> Self {
12727        Self {
12728            s_type: StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
12729            p_next: ::std::ptr::null(),
12730            stage_count: u32::default(),
12731            p_stages: ::std::ptr::null(),
12732            p_vertex_input_state: ::std::ptr::null(),
12733            p_tessellation_state: ::std::ptr::null(),
12734        }
12735    }
12736}
12737impl GraphicsShaderGroupCreateInfoNV {
12738    pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12739        GraphicsShaderGroupCreateInfoNVBuilder {
12740            inner: Self::default(),
12741            marker: ::std::marker::PhantomData,
12742        }
12743    }
12744}
12745#[repr(transparent)]
12746pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12747    inner: GraphicsShaderGroupCreateInfoNV,
12748    marker: ::std::marker::PhantomData<&'a ()>,
12749}
12750impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12751    type Target = GraphicsShaderGroupCreateInfoNV;
12752    fn deref(&self) -> &Self::Target {
12753        &self.inner
12754    }
12755}
12756impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12757    fn deref_mut(&mut self) -> &mut Self::Target {
12758        &mut self.inner
12759    }
12760}
12761impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
12762    pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
12763        self.inner.stage_count = stages.len() as _;
12764        self.inner.p_stages = stages.as_ptr();
12765        self
12766    }
12767    pub fn vertex_input_state(
12768        mut self,
12769        vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
12770    ) -> Self {
12771        self.inner.p_vertex_input_state = vertex_input_state;
12772        self
12773    }
12774    pub fn tessellation_state(
12775        mut self,
12776        tessellation_state: &'a PipelineTessellationStateCreateInfo,
12777    ) -> Self {
12778        self.inner.p_tessellation_state = tessellation_state;
12779        self
12780    }
12781    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12782    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12783    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12784    pub fn build(self) -> GraphicsShaderGroupCreateInfoNV {
12785        self.inner
12786    }
12787}
12788#[repr(C)]
12789#[cfg_attr(feature = "debug", derive(Debug))]
12790#[derive(Copy, Clone)]
12791#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>"]
12792pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
12793    pub s_type: StructureType,
12794    pub p_next: *const c_void,
12795    pub group_count: u32,
12796    pub p_groups: *const GraphicsShaderGroupCreateInfoNV,
12797    pub pipeline_count: u32,
12798    pub p_pipelines: *const Pipeline,
12799}
12800impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV {
12801    fn default() -> Self {
12802        Self {
12803            s_type: StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
12804            p_next: ::std::ptr::null(),
12805            group_count: u32::default(),
12806            p_groups: ::std::ptr::null(),
12807            pipeline_count: u32::default(),
12808            p_pipelines: ::std::ptr::null(),
12809        }
12810    }
12811}
12812impl GraphicsPipelineShaderGroupsCreateInfoNV {
12813    pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12814        GraphicsPipelineShaderGroupsCreateInfoNVBuilder {
12815            inner: Self::default(),
12816            marker: ::std::marker::PhantomData,
12817        }
12818    }
12819}
12820#[repr(transparent)]
12821pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12822    inner: GraphicsPipelineShaderGroupsCreateInfoNV,
12823    marker: ::std::marker::PhantomData<&'a ()>,
12824}
12825unsafe impl ExtendsGraphicsPipelineCreateInfo
12826    for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_>
12827{
12828}
12829unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {}
12830impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12831    type Target = GraphicsPipelineShaderGroupsCreateInfoNV;
12832    fn deref(&self) -> &Self::Target {
12833        &self.inner
12834    }
12835}
12836impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12837    fn deref_mut(&mut self) -> &mut Self::Target {
12838        &mut self.inner
12839    }
12840}
12841impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
12842    pub fn groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self {
12843        self.inner.group_count = groups.len() as _;
12844        self.inner.p_groups = groups.as_ptr();
12845        self
12846    }
12847    pub fn pipelines(mut self, pipelines: &'a [Pipeline]) -> Self {
12848        self.inner.pipeline_count = pipelines.len() as _;
12849        self.inner.p_pipelines = pipelines.as_ptr();
12850        self
12851    }
12852    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12853    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12854    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12855    pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV {
12856        self.inner
12857    }
12858}
12859#[repr(C)]
12860#[cfg_attr(feature = "debug", derive(Debug))]
12861#[derive(Copy, Clone, Default)]
12862#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html>"]
12863pub struct BindShaderGroupIndirectCommandNV {
12864    pub group_index: u32,
12865}
12866impl BindShaderGroupIndirectCommandNV {
12867    pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
12868        BindShaderGroupIndirectCommandNVBuilder {
12869            inner: Self::default(),
12870            marker: ::std::marker::PhantomData,
12871        }
12872    }
12873}
12874#[repr(transparent)]
12875pub struct BindShaderGroupIndirectCommandNVBuilder<'a> {
12876    inner: BindShaderGroupIndirectCommandNV,
12877    marker: ::std::marker::PhantomData<&'a ()>,
12878}
12879impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> {
12880    type Target = BindShaderGroupIndirectCommandNV;
12881    fn deref(&self) -> &Self::Target {
12882        &self.inner
12883    }
12884}
12885impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> {
12886    fn deref_mut(&mut self) -> &mut Self::Target {
12887        &mut self.inner
12888    }
12889}
12890impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
12891    pub fn group_index(mut self, group_index: u32) -> Self {
12892        self.inner.group_index = group_index;
12893        self
12894    }
12895    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12896    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12897    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12898    pub fn build(self) -> BindShaderGroupIndirectCommandNV {
12899        self.inner
12900    }
12901}
12902#[repr(C)]
12903#[cfg_attr(feature = "debug", derive(Debug))]
12904#[derive(Copy, Clone, Default)]
12905#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html>"]
12906pub struct BindIndexBufferIndirectCommandNV {
12907    pub buffer_address: DeviceAddress,
12908    pub size: u32,
12909    pub index_type: IndexType,
12910}
12911impl BindIndexBufferIndirectCommandNV {
12912    pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
12913        BindIndexBufferIndirectCommandNVBuilder {
12914            inner: Self::default(),
12915            marker: ::std::marker::PhantomData,
12916        }
12917    }
12918}
12919#[repr(transparent)]
12920pub struct BindIndexBufferIndirectCommandNVBuilder<'a> {
12921    inner: BindIndexBufferIndirectCommandNV,
12922    marker: ::std::marker::PhantomData<&'a ()>,
12923}
12924impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> {
12925    type Target = BindIndexBufferIndirectCommandNV;
12926    fn deref(&self) -> &Self::Target {
12927        &self.inner
12928    }
12929}
12930impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> {
12931    fn deref_mut(&mut self) -> &mut Self::Target {
12932        &mut self.inner
12933    }
12934}
12935impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
12936    pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
12937        self.inner.buffer_address = buffer_address;
12938        self
12939    }
12940    pub fn size(mut self, size: u32) -> Self {
12941        self.inner.size = size;
12942        self
12943    }
12944    pub fn index_type(mut self, index_type: IndexType) -> Self {
12945        self.inner.index_type = index_type;
12946        self
12947    }
12948    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12949    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12950    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
12951    pub fn build(self) -> BindIndexBufferIndirectCommandNV {
12952        self.inner
12953    }
12954}
12955#[repr(C)]
12956#[cfg_attr(feature = "debug", derive(Debug))]
12957#[derive(Copy, Clone, Default)]
12958#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html>"]
12959pub struct BindVertexBufferIndirectCommandNV {
12960    pub buffer_address: DeviceAddress,
12961    pub size: u32,
12962    pub stride: u32,
12963}
12964impl BindVertexBufferIndirectCommandNV {
12965    pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
12966        BindVertexBufferIndirectCommandNVBuilder {
12967            inner: Self::default(),
12968            marker: ::std::marker::PhantomData,
12969        }
12970    }
12971}
12972#[repr(transparent)]
12973pub struct BindVertexBufferIndirectCommandNVBuilder<'a> {
12974    inner: BindVertexBufferIndirectCommandNV,
12975    marker: ::std::marker::PhantomData<&'a ()>,
12976}
12977impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> {
12978    type Target = BindVertexBufferIndirectCommandNV;
12979    fn deref(&self) -> &Self::Target {
12980        &self.inner
12981    }
12982}
12983impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> {
12984    fn deref_mut(&mut self) -> &mut Self::Target {
12985        &mut self.inner
12986    }
12987}
12988impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
12989    pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
12990        self.inner.buffer_address = buffer_address;
12991        self
12992    }
12993    pub fn size(mut self, size: u32) -> Self {
12994        self.inner.size = size;
12995        self
12996    }
12997    pub fn stride(mut self, stride: u32) -> Self {
12998        self.inner.stride = stride;
12999        self
13000    }
13001    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13002    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13003    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13004    pub fn build(self) -> BindVertexBufferIndirectCommandNV {
13005        self.inner
13006    }
13007}
13008#[repr(C)]
13009#[cfg_attr(feature = "debug", derive(Debug))]
13010#[derive(Copy, Clone, Default)]
13011#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html>"]
13012pub struct SetStateFlagsIndirectCommandNV {
13013    pub data: u32,
13014}
13015impl SetStateFlagsIndirectCommandNV {
13016    pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
13017        SetStateFlagsIndirectCommandNVBuilder {
13018            inner: Self::default(),
13019            marker: ::std::marker::PhantomData,
13020        }
13021    }
13022}
13023#[repr(transparent)]
13024pub struct SetStateFlagsIndirectCommandNVBuilder<'a> {
13025    inner: SetStateFlagsIndirectCommandNV,
13026    marker: ::std::marker::PhantomData<&'a ()>,
13027}
13028impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> {
13029    type Target = SetStateFlagsIndirectCommandNV;
13030    fn deref(&self) -> &Self::Target {
13031        &self.inner
13032    }
13033}
13034impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> {
13035    fn deref_mut(&mut self) -> &mut Self::Target {
13036        &mut self.inner
13037    }
13038}
13039impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
13040    pub fn data(mut self, data: u32) -> Self {
13041        self.inner.data = data;
13042        self
13043    }
13044    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13045    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13046    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13047    pub fn build(self) -> SetStateFlagsIndirectCommandNV {
13048        self.inner
13049    }
13050}
13051#[repr(C)]
13052#[cfg_attr(feature = "debug", derive(Debug))]
13053#[derive(Copy, Clone, Default)]
13054#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsStreamNV.html>"]
13055pub struct IndirectCommandsStreamNV {
13056    pub buffer: Buffer,
13057    pub offset: DeviceSize,
13058}
13059impl IndirectCommandsStreamNV {
13060    pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> {
13061        IndirectCommandsStreamNVBuilder {
13062            inner: Self::default(),
13063            marker: ::std::marker::PhantomData,
13064        }
13065    }
13066}
13067#[repr(transparent)]
13068pub struct IndirectCommandsStreamNVBuilder<'a> {
13069    inner: IndirectCommandsStreamNV,
13070    marker: ::std::marker::PhantomData<&'a ()>,
13071}
13072impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> {
13073    type Target = IndirectCommandsStreamNV;
13074    fn deref(&self) -> &Self::Target {
13075        &self.inner
13076    }
13077}
13078impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> {
13079    fn deref_mut(&mut self) -> &mut Self::Target {
13080        &mut self.inner
13081    }
13082}
13083impl<'a> IndirectCommandsStreamNVBuilder<'a> {
13084    pub fn buffer(mut self, buffer: Buffer) -> Self {
13085        self.inner.buffer = buffer;
13086        self
13087    }
13088    pub fn offset(mut self, offset: DeviceSize) -> Self {
13089        self.inner.offset = offset;
13090        self
13091    }
13092    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13093    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13094    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13095    pub fn build(self) -> IndirectCommandsStreamNV {
13096        self.inner
13097    }
13098}
13099#[repr(C)]
13100#[cfg_attr(feature = "debug", derive(Debug))]
13101#[derive(Copy, Clone)]
13102#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html>"]
13103pub struct IndirectCommandsLayoutTokenNV {
13104    pub s_type: StructureType,
13105    pub p_next: *const c_void,
13106    pub token_type: IndirectCommandsTokenTypeNV,
13107    pub stream: u32,
13108    pub offset: u32,
13109    pub vertex_binding_unit: u32,
13110    pub vertex_dynamic_stride: Bool32,
13111    pub pushconstant_pipeline_layout: PipelineLayout,
13112    pub pushconstant_shader_stage_flags: ShaderStageFlags,
13113    pub pushconstant_offset: u32,
13114    pub pushconstant_size: u32,
13115    pub indirect_state_flags: IndirectStateFlagsNV,
13116    pub index_type_count: u32,
13117    pub p_index_types: *const IndexType,
13118    pub p_index_type_values: *const u32,
13119}
13120impl ::std::default::Default for IndirectCommandsLayoutTokenNV {
13121    fn default() -> Self {
13122        Self {
13123            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
13124            p_next: ::std::ptr::null(),
13125            token_type: IndirectCommandsTokenTypeNV::default(),
13126            stream: u32::default(),
13127            offset: u32::default(),
13128            vertex_binding_unit: u32::default(),
13129            vertex_dynamic_stride: Bool32::default(),
13130            pushconstant_pipeline_layout: PipelineLayout::default(),
13131            pushconstant_shader_stage_flags: ShaderStageFlags::default(),
13132            pushconstant_offset: u32::default(),
13133            pushconstant_size: u32::default(),
13134            indirect_state_flags: IndirectStateFlagsNV::default(),
13135            index_type_count: u32::default(),
13136            p_index_types: ::std::ptr::null(),
13137            p_index_type_values: ::std::ptr::null(),
13138        }
13139    }
13140}
13141impl IndirectCommandsLayoutTokenNV {
13142    pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
13143        IndirectCommandsLayoutTokenNVBuilder {
13144            inner: Self::default(),
13145            marker: ::std::marker::PhantomData,
13146        }
13147    }
13148}
13149#[repr(transparent)]
13150pub struct IndirectCommandsLayoutTokenNVBuilder<'a> {
13151    inner: IndirectCommandsLayoutTokenNV,
13152    marker: ::std::marker::PhantomData<&'a ()>,
13153}
13154impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
13155    type Target = IndirectCommandsLayoutTokenNV;
13156    fn deref(&self) -> &Self::Target {
13157        &self.inner
13158    }
13159}
13160impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
13161    fn deref_mut(&mut self) -> &mut Self::Target {
13162        &mut self.inner
13163    }
13164}
13165impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
13166    pub fn token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self {
13167        self.inner.token_type = token_type;
13168        self
13169    }
13170    pub fn stream(mut self, stream: u32) -> Self {
13171        self.inner.stream = stream;
13172        self
13173    }
13174    pub fn offset(mut self, offset: u32) -> Self {
13175        self.inner.offset = offset;
13176        self
13177    }
13178    pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self {
13179        self.inner.vertex_binding_unit = vertex_binding_unit;
13180        self
13181    }
13182    pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self {
13183        self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into();
13184        self
13185    }
13186    pub fn pushconstant_pipeline_layout(
13187        mut self,
13188        pushconstant_pipeline_layout: PipelineLayout,
13189    ) -> Self {
13190        self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout;
13191        self
13192    }
13193    pub fn pushconstant_shader_stage_flags(
13194        mut self,
13195        pushconstant_shader_stage_flags: ShaderStageFlags,
13196    ) -> Self {
13197        self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags;
13198        self
13199    }
13200    pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self {
13201        self.inner.pushconstant_offset = pushconstant_offset;
13202        self
13203    }
13204    pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self {
13205        self.inner.pushconstant_size = pushconstant_size;
13206        self
13207    }
13208    pub fn indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self {
13209        self.inner.indirect_state_flags = indirect_state_flags;
13210        self
13211    }
13212    pub fn index_types(mut self, index_types: &'a [IndexType]) -> Self {
13213        self.inner.index_type_count = index_types.len() as _;
13214        self.inner.p_index_types = index_types.as_ptr();
13215        self
13216    }
13217    pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self {
13218        self.inner.index_type_count = index_type_values.len() as _;
13219        self.inner.p_index_type_values = index_type_values.as_ptr();
13220        self
13221    }
13222    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13223    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13224    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13225    pub fn build(self) -> IndirectCommandsLayoutTokenNV {
13226        self.inner
13227    }
13228}
13229#[repr(C)]
13230#[cfg_attr(feature = "debug", derive(Debug))]
13231#[derive(Copy, Clone)]
13232#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>"]
13233pub struct IndirectCommandsLayoutCreateInfoNV {
13234    pub s_type: StructureType,
13235    pub p_next: *const c_void,
13236    pub flags: IndirectCommandsLayoutUsageFlagsNV,
13237    pub pipeline_bind_point: PipelineBindPoint,
13238    pub token_count: u32,
13239    pub p_tokens: *const IndirectCommandsLayoutTokenNV,
13240    pub stream_count: u32,
13241    pub p_stream_strides: *const u32,
13242}
13243impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV {
13244    fn default() -> Self {
13245        Self {
13246            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
13247            p_next: ::std::ptr::null(),
13248            flags: IndirectCommandsLayoutUsageFlagsNV::default(),
13249            pipeline_bind_point: PipelineBindPoint::default(),
13250            token_count: u32::default(),
13251            p_tokens: ::std::ptr::null(),
13252            stream_count: u32::default(),
13253            p_stream_strides: ::std::ptr::null(),
13254        }
13255    }
13256}
13257impl IndirectCommandsLayoutCreateInfoNV {
13258    pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13259        IndirectCommandsLayoutCreateInfoNVBuilder {
13260            inner: Self::default(),
13261            marker: ::std::marker::PhantomData,
13262        }
13263    }
13264}
13265#[repr(transparent)]
13266pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13267    inner: IndirectCommandsLayoutCreateInfoNV,
13268    marker: ::std::marker::PhantomData<&'a ()>,
13269}
13270impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13271    type Target = IndirectCommandsLayoutCreateInfoNV;
13272    fn deref(&self) -> &Self::Target {
13273        &self.inner
13274    }
13275}
13276impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13277    fn deref_mut(&mut self) -> &mut Self::Target {
13278        &mut self.inner
13279    }
13280}
13281impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
13282    pub fn flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self {
13283        self.inner.flags = flags;
13284        self
13285    }
13286    pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
13287        self.inner.pipeline_bind_point = pipeline_bind_point;
13288        self
13289    }
13290    pub fn tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self {
13291        self.inner.token_count = tokens.len() as _;
13292        self.inner.p_tokens = tokens.as_ptr();
13293        self
13294    }
13295    pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self {
13296        self.inner.stream_count = stream_strides.len() as _;
13297        self.inner.p_stream_strides = stream_strides.as_ptr();
13298        self
13299    }
13300    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13301    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13302    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13303    pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV {
13304        self.inner
13305    }
13306}
13307#[repr(C)]
13308#[cfg_attr(feature = "debug", derive(Debug))]
13309#[derive(Copy, Clone)]
13310#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsInfoNV.html>"]
13311pub struct GeneratedCommandsInfoNV {
13312    pub s_type: StructureType,
13313    pub p_next: *const c_void,
13314    pub pipeline_bind_point: PipelineBindPoint,
13315    pub pipeline: Pipeline,
13316    pub indirect_commands_layout: IndirectCommandsLayoutNV,
13317    pub stream_count: u32,
13318    pub p_streams: *const IndirectCommandsStreamNV,
13319    pub sequences_count: u32,
13320    pub preprocess_buffer: Buffer,
13321    pub preprocess_offset: DeviceSize,
13322    pub preprocess_size: DeviceSize,
13323    pub sequences_count_buffer: Buffer,
13324    pub sequences_count_offset: DeviceSize,
13325    pub sequences_index_buffer: Buffer,
13326    pub sequences_index_offset: DeviceSize,
13327}
13328impl ::std::default::Default for GeneratedCommandsInfoNV {
13329    fn default() -> Self {
13330        Self {
13331            s_type: StructureType::GENERATED_COMMANDS_INFO_NV,
13332            p_next: ::std::ptr::null(),
13333            pipeline_bind_point: PipelineBindPoint::default(),
13334            pipeline: Pipeline::default(),
13335            indirect_commands_layout: IndirectCommandsLayoutNV::default(),
13336            stream_count: u32::default(),
13337            p_streams: ::std::ptr::null(),
13338            sequences_count: u32::default(),
13339            preprocess_buffer: Buffer::default(),
13340            preprocess_offset: DeviceSize::default(),
13341            preprocess_size: DeviceSize::default(),
13342            sequences_count_buffer: Buffer::default(),
13343            sequences_count_offset: DeviceSize::default(),
13344            sequences_index_buffer: Buffer::default(),
13345            sequences_index_offset: DeviceSize::default(),
13346        }
13347    }
13348}
13349impl GeneratedCommandsInfoNV {
13350    pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> {
13351        GeneratedCommandsInfoNVBuilder {
13352            inner: Self::default(),
13353            marker: ::std::marker::PhantomData,
13354        }
13355    }
13356}
13357#[repr(transparent)]
13358pub struct GeneratedCommandsInfoNVBuilder<'a> {
13359    inner: GeneratedCommandsInfoNV,
13360    marker: ::std::marker::PhantomData<&'a ()>,
13361}
13362impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> {
13363    type Target = GeneratedCommandsInfoNV;
13364    fn deref(&self) -> &Self::Target {
13365        &self.inner
13366    }
13367}
13368impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
13369    fn deref_mut(&mut self) -> &mut Self::Target {
13370        &mut self.inner
13371    }
13372}
13373impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
13374    pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
13375        self.inner.pipeline_bind_point = pipeline_bind_point;
13376        self
13377    }
13378    pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
13379        self.inner.pipeline = pipeline;
13380        self
13381    }
13382    pub fn indirect_commands_layout(
13383        mut self,
13384        indirect_commands_layout: IndirectCommandsLayoutNV,
13385    ) -> Self {
13386        self.inner.indirect_commands_layout = indirect_commands_layout;
13387        self
13388    }
13389    pub fn streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self {
13390        self.inner.stream_count = streams.len() as _;
13391        self.inner.p_streams = streams.as_ptr();
13392        self
13393    }
13394    pub fn sequences_count(mut self, sequences_count: u32) -> Self {
13395        self.inner.sequences_count = sequences_count;
13396        self
13397    }
13398    pub fn preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self {
13399        self.inner.preprocess_buffer = preprocess_buffer;
13400        self
13401    }
13402    pub fn preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self {
13403        self.inner.preprocess_offset = preprocess_offset;
13404        self
13405    }
13406    pub fn preprocess_size(mut self, preprocess_size: DeviceSize) -> Self {
13407        self.inner.preprocess_size = preprocess_size;
13408        self
13409    }
13410    pub fn sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self {
13411        self.inner.sequences_count_buffer = sequences_count_buffer;
13412        self
13413    }
13414    pub fn sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self {
13415        self.inner.sequences_count_offset = sequences_count_offset;
13416        self
13417    }
13418    pub fn sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self {
13419        self.inner.sequences_index_buffer = sequences_index_buffer;
13420        self
13421    }
13422    pub fn sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self {
13423        self.inner.sequences_index_offset = sequences_index_offset;
13424        self
13425    }
13426    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13427    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13428    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13429    pub fn build(self) -> GeneratedCommandsInfoNV {
13430        self.inner
13431    }
13432}
13433#[repr(C)]
13434#[cfg_attr(feature = "debug", derive(Debug))]
13435#[derive(Copy, Clone)]
13436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>"]
13437pub struct GeneratedCommandsMemoryRequirementsInfoNV {
13438    pub s_type: StructureType,
13439    pub p_next: *const c_void,
13440    pub pipeline_bind_point: PipelineBindPoint,
13441    pub pipeline: Pipeline,
13442    pub indirect_commands_layout: IndirectCommandsLayoutNV,
13443    pub max_sequences_count: u32,
13444}
13445impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV {
13446    fn default() -> Self {
13447        Self {
13448            s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
13449            p_next: ::std::ptr::null(),
13450            pipeline_bind_point: PipelineBindPoint::default(),
13451            pipeline: Pipeline::default(),
13452            indirect_commands_layout: IndirectCommandsLayoutNV::default(),
13453            max_sequences_count: u32::default(),
13454        }
13455    }
13456}
13457impl GeneratedCommandsMemoryRequirementsInfoNV {
13458    pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13459        GeneratedCommandsMemoryRequirementsInfoNVBuilder {
13460            inner: Self::default(),
13461            marker: ::std::marker::PhantomData,
13462        }
13463    }
13464}
13465#[repr(transparent)]
13466pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13467    inner: GeneratedCommandsMemoryRequirementsInfoNV,
13468    marker: ::std::marker::PhantomData<&'a ()>,
13469}
13470impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13471    type Target = GeneratedCommandsMemoryRequirementsInfoNV;
13472    fn deref(&self) -> &Self::Target {
13473        &self.inner
13474    }
13475}
13476impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13477    fn deref_mut(&mut self) -> &mut Self::Target {
13478        &mut self.inner
13479    }
13480}
13481impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
13482    pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
13483        self.inner.pipeline_bind_point = pipeline_bind_point;
13484        self
13485    }
13486    pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
13487        self.inner.pipeline = pipeline;
13488        self
13489    }
13490    pub fn indirect_commands_layout(
13491        mut self,
13492        indirect_commands_layout: IndirectCommandsLayoutNV,
13493    ) -> Self {
13494        self.inner.indirect_commands_layout = indirect_commands_layout;
13495        self
13496    }
13497    pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self {
13498        self.inner.max_sequences_count = max_sequences_count;
13499        self
13500    }
13501    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13502    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13503    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13504    pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV {
13505        self.inner
13506    }
13507}
13508#[repr(C)]
13509#[cfg_attr(feature = "debug", derive(Debug))]
13510#[derive(Copy, Clone)]
13511#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures2.html>"]
13512pub struct PhysicalDeviceFeatures2 {
13513    pub s_type: StructureType,
13514    pub p_next: *mut c_void,
13515    pub features: PhysicalDeviceFeatures,
13516}
13517impl ::std::default::Default for PhysicalDeviceFeatures2 {
13518    fn default() -> Self {
13519        Self {
13520            s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2,
13521            p_next: ::std::ptr::null_mut(),
13522            features: PhysicalDeviceFeatures::default(),
13523        }
13524    }
13525}
13526impl PhysicalDeviceFeatures2 {
13527    pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> {
13528        PhysicalDeviceFeatures2Builder {
13529            inner: Self::default(),
13530            marker: ::std::marker::PhantomData,
13531        }
13532    }
13533}
13534#[repr(transparent)]
13535pub struct PhysicalDeviceFeatures2Builder<'a> {
13536    inner: PhysicalDeviceFeatures2,
13537    marker: ::std::marker::PhantomData<&'a ()>,
13538}
13539unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {}
13540unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {}
13541pub unsafe trait ExtendsPhysicalDeviceFeatures2 {}
13542impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> {
13543    type Target = PhysicalDeviceFeatures2;
13544    fn deref(&self) -> &Self::Target {
13545        &self.inner
13546    }
13547}
13548impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> {
13549    fn deref_mut(&mut self) -> &mut Self::Target {
13550        &mut self.inner
13551    }
13552}
13553impl<'a> PhysicalDeviceFeatures2Builder<'a> {
13554    pub fn features(mut self, features: PhysicalDeviceFeatures) -> Self {
13555        self.inner.features = features;
13556        self
13557    }
13558    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13559    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13560    #[doc = r" valid extension structs can be pushed into the chain."]
13561    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13562    #[doc = r" chain will look like `A -> D -> B -> C`."]
13563    pub fn push_next<T: ExtendsPhysicalDeviceFeatures2>(mut self, next: &'a mut T) -> Self {
13564        unsafe {
13565            let next_ptr = <*mut T>::cast(next);
13566            let last_next = ptr_chain_iter(next).last().unwrap();
13567            (*last_next).p_next = self.inner.p_next as _;
13568            self.inner.p_next = next_ptr;
13569        }
13570        self
13571    }
13572    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13573    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13574    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13575    pub fn build(self) -> PhysicalDeviceFeatures2 {
13576        self.inner
13577    }
13578}
13579#[repr(C)]
13580#[cfg_attr(feature = "debug", derive(Debug))]
13581#[derive(Copy, Clone)]
13582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties2.html>"]
13583pub struct PhysicalDeviceProperties2 {
13584    pub s_type: StructureType,
13585    pub p_next: *mut c_void,
13586    pub properties: PhysicalDeviceProperties,
13587}
13588impl ::std::default::Default for PhysicalDeviceProperties2 {
13589    fn default() -> Self {
13590        Self {
13591            s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2,
13592            p_next: ::std::ptr::null_mut(),
13593            properties: PhysicalDeviceProperties::default(),
13594        }
13595    }
13596}
13597impl PhysicalDeviceProperties2 {
13598    pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> {
13599        PhysicalDeviceProperties2Builder {
13600            inner: Self::default(),
13601            marker: ::std::marker::PhantomData,
13602        }
13603    }
13604}
13605#[repr(transparent)]
13606pub struct PhysicalDeviceProperties2Builder<'a> {
13607    inner: PhysicalDeviceProperties2,
13608    marker: ::std::marker::PhantomData<&'a ()>,
13609}
13610pub unsafe trait ExtendsPhysicalDeviceProperties2 {}
13611impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> {
13612    type Target = PhysicalDeviceProperties2;
13613    fn deref(&self) -> &Self::Target {
13614        &self.inner
13615    }
13616}
13617impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> {
13618    fn deref_mut(&mut self) -> &mut Self::Target {
13619        &mut self.inner
13620    }
13621}
13622impl<'a> PhysicalDeviceProperties2Builder<'a> {
13623    pub fn properties(mut self, properties: PhysicalDeviceProperties) -> Self {
13624        self.inner.properties = properties;
13625        self
13626    }
13627    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13628    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13629    #[doc = r" valid extension structs can be pushed into the chain."]
13630    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13631    #[doc = r" chain will look like `A -> D -> B -> C`."]
13632    pub fn push_next<T: ExtendsPhysicalDeviceProperties2>(mut self, next: &'a mut T) -> Self {
13633        unsafe {
13634            let next_ptr = <*mut T>::cast(next);
13635            let last_next = ptr_chain_iter(next).last().unwrap();
13636            (*last_next).p_next = self.inner.p_next as _;
13637            self.inner.p_next = next_ptr;
13638        }
13639        self
13640    }
13641    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13642    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13643    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13644    pub fn build(self) -> PhysicalDeviceProperties2 {
13645        self.inner
13646    }
13647}
13648#[repr(C)]
13649#[cfg_attr(feature = "debug", derive(Debug))]
13650#[derive(Copy, Clone)]
13651#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties2.html>"]
13652pub struct FormatProperties2 {
13653    pub s_type: StructureType,
13654    pub p_next: *mut c_void,
13655    pub format_properties: FormatProperties,
13656}
13657impl ::std::default::Default for FormatProperties2 {
13658    fn default() -> Self {
13659        Self {
13660            s_type: StructureType::FORMAT_PROPERTIES_2,
13661            p_next: ::std::ptr::null_mut(),
13662            format_properties: FormatProperties::default(),
13663        }
13664    }
13665}
13666impl FormatProperties2 {
13667    pub fn builder<'a>() -> FormatProperties2Builder<'a> {
13668        FormatProperties2Builder {
13669            inner: Self::default(),
13670            marker: ::std::marker::PhantomData,
13671        }
13672    }
13673}
13674#[repr(transparent)]
13675pub struct FormatProperties2Builder<'a> {
13676    inner: FormatProperties2,
13677    marker: ::std::marker::PhantomData<&'a ()>,
13678}
13679pub unsafe trait ExtendsFormatProperties2 {}
13680impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> {
13681    type Target = FormatProperties2;
13682    fn deref(&self) -> &Self::Target {
13683        &self.inner
13684    }
13685}
13686impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> {
13687    fn deref_mut(&mut self) -> &mut Self::Target {
13688        &mut self.inner
13689    }
13690}
13691impl<'a> FormatProperties2Builder<'a> {
13692    pub fn format_properties(mut self, format_properties: FormatProperties) -> Self {
13693        self.inner.format_properties = format_properties;
13694        self
13695    }
13696    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13697    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13698    #[doc = r" valid extension structs can be pushed into the chain."]
13699    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13700    #[doc = r" chain will look like `A -> D -> B -> C`."]
13701    pub fn push_next<T: ExtendsFormatProperties2>(mut self, next: &'a mut T) -> Self {
13702        unsafe {
13703            let next_ptr = <*mut T>::cast(next);
13704            let last_next = ptr_chain_iter(next).last().unwrap();
13705            (*last_next).p_next = self.inner.p_next as _;
13706            self.inner.p_next = next_ptr;
13707        }
13708        self
13709    }
13710    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13711    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13712    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13713    pub fn build(self) -> FormatProperties2 {
13714        self.inner
13715    }
13716}
13717#[repr(C)]
13718#[cfg_attr(feature = "debug", derive(Debug))]
13719#[derive(Copy, Clone)]
13720#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties2.html>"]
13721pub struct ImageFormatProperties2 {
13722    pub s_type: StructureType,
13723    pub p_next: *mut c_void,
13724    pub image_format_properties: ImageFormatProperties,
13725}
13726impl ::std::default::Default for ImageFormatProperties2 {
13727    fn default() -> Self {
13728        Self {
13729            s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2,
13730            p_next: ::std::ptr::null_mut(),
13731            image_format_properties: ImageFormatProperties::default(),
13732        }
13733    }
13734}
13735impl ImageFormatProperties2 {
13736    pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> {
13737        ImageFormatProperties2Builder {
13738            inner: Self::default(),
13739            marker: ::std::marker::PhantomData,
13740        }
13741    }
13742}
13743#[repr(transparent)]
13744pub struct ImageFormatProperties2Builder<'a> {
13745    inner: ImageFormatProperties2,
13746    marker: ::std::marker::PhantomData<&'a ()>,
13747}
13748pub unsafe trait ExtendsImageFormatProperties2 {}
13749impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> {
13750    type Target = ImageFormatProperties2;
13751    fn deref(&self) -> &Self::Target {
13752        &self.inner
13753    }
13754}
13755impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> {
13756    fn deref_mut(&mut self) -> &mut Self::Target {
13757        &mut self.inner
13758    }
13759}
13760impl<'a> ImageFormatProperties2Builder<'a> {
13761    pub fn image_format_properties(
13762        mut self,
13763        image_format_properties: ImageFormatProperties,
13764    ) -> Self {
13765        self.inner.image_format_properties = image_format_properties;
13766        self
13767    }
13768    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13769    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13770    #[doc = r" valid extension structs can be pushed into the chain."]
13771    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13772    #[doc = r" chain will look like `A -> D -> B -> C`."]
13773    pub fn push_next<T: ExtendsImageFormatProperties2>(mut self, next: &'a mut T) -> Self {
13774        unsafe {
13775            let next_ptr = <*mut T>::cast(next);
13776            let last_next = ptr_chain_iter(next).last().unwrap();
13777            (*last_next).p_next = self.inner.p_next as _;
13778            self.inner.p_next = next_ptr;
13779        }
13780        self
13781    }
13782    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13783    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13784    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13785    pub fn build(self) -> ImageFormatProperties2 {
13786        self.inner
13787    }
13788}
13789#[repr(C)]
13790#[cfg_attr(feature = "debug", derive(Debug))]
13791#[derive(Copy, Clone)]
13792#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html>"]
13793pub struct PhysicalDeviceImageFormatInfo2 {
13794    pub s_type: StructureType,
13795    pub p_next: *const c_void,
13796    pub format: Format,
13797    pub ty: ImageType,
13798    pub tiling: ImageTiling,
13799    pub usage: ImageUsageFlags,
13800    pub flags: ImageCreateFlags,
13801}
13802impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 {
13803    fn default() -> Self {
13804        Self {
13805            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
13806            p_next: ::std::ptr::null(),
13807            format: Format::default(),
13808            ty: ImageType::default(),
13809            tiling: ImageTiling::default(),
13810            usage: ImageUsageFlags::default(),
13811            flags: ImageCreateFlags::default(),
13812        }
13813    }
13814}
13815impl PhysicalDeviceImageFormatInfo2 {
13816    pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> {
13817        PhysicalDeviceImageFormatInfo2Builder {
13818            inner: Self::default(),
13819            marker: ::std::marker::PhantomData,
13820        }
13821    }
13822}
13823#[repr(transparent)]
13824pub struct PhysicalDeviceImageFormatInfo2Builder<'a> {
13825    inner: PhysicalDeviceImageFormatInfo2,
13826    marker: ::std::marker::PhantomData<&'a ()>,
13827}
13828pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {}
13829impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> {
13830    type Target = PhysicalDeviceImageFormatInfo2;
13831    fn deref(&self) -> &Self::Target {
13832        &self.inner
13833    }
13834}
13835impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> {
13836    fn deref_mut(&mut self) -> &mut Self::Target {
13837        &mut self.inner
13838    }
13839}
13840impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
13841    pub fn format(mut self, format: Format) -> Self {
13842        self.inner.format = format;
13843        self
13844    }
13845    pub fn ty(mut self, ty: ImageType) -> Self {
13846        self.inner.ty = ty;
13847        self
13848    }
13849    pub fn tiling(mut self, tiling: ImageTiling) -> Self {
13850        self.inner.tiling = tiling;
13851        self
13852    }
13853    pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
13854        self.inner.usage = usage;
13855        self
13856    }
13857    pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
13858        self.inner.flags = flags;
13859        self
13860    }
13861    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13862    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13863    #[doc = r" valid extension structs can be pushed into the chain."]
13864    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13865    #[doc = r" chain will look like `A -> D -> B -> C`."]
13866    pub fn push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(mut self, next: &'a mut T) -> Self {
13867        unsafe {
13868            let next_ptr = <*const T>::cast(next);
13869            let last_next = ptr_chain_iter(next).last().unwrap();
13870            (*last_next).p_next = self.inner.p_next as _;
13871            self.inner.p_next = next_ptr;
13872        }
13873        self
13874    }
13875    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13876    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13877    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13878    pub fn build(self) -> PhysicalDeviceImageFormatInfo2 {
13879        self.inner
13880    }
13881}
13882#[repr(C)]
13883#[cfg_attr(feature = "debug", derive(Debug))]
13884#[derive(Copy, Clone)]
13885#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties2.html>"]
13886pub struct QueueFamilyProperties2 {
13887    pub s_type: StructureType,
13888    pub p_next: *mut c_void,
13889    pub queue_family_properties: QueueFamilyProperties,
13890}
13891impl ::std::default::Default for QueueFamilyProperties2 {
13892    fn default() -> Self {
13893        Self {
13894            s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2,
13895            p_next: ::std::ptr::null_mut(),
13896            queue_family_properties: QueueFamilyProperties::default(),
13897        }
13898    }
13899}
13900impl QueueFamilyProperties2 {
13901    pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> {
13902        QueueFamilyProperties2Builder {
13903            inner: Self::default(),
13904            marker: ::std::marker::PhantomData,
13905        }
13906    }
13907}
13908#[repr(transparent)]
13909pub struct QueueFamilyProperties2Builder<'a> {
13910    inner: QueueFamilyProperties2,
13911    marker: ::std::marker::PhantomData<&'a ()>,
13912}
13913pub unsafe trait ExtendsQueueFamilyProperties2 {}
13914impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> {
13915    type Target = QueueFamilyProperties2;
13916    fn deref(&self) -> &Self::Target {
13917        &self.inner
13918    }
13919}
13920impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> {
13921    fn deref_mut(&mut self) -> &mut Self::Target {
13922        &mut self.inner
13923    }
13924}
13925impl<'a> QueueFamilyProperties2Builder<'a> {
13926    pub fn queue_family_properties(
13927        mut self,
13928        queue_family_properties: QueueFamilyProperties,
13929    ) -> Self {
13930        self.inner.queue_family_properties = queue_family_properties;
13931        self
13932    }
13933    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13934    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13935    #[doc = r" valid extension structs can be pushed into the chain."]
13936    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13937    #[doc = r" chain will look like `A -> D -> B -> C`."]
13938    pub fn push_next<T: ExtendsQueueFamilyProperties2>(mut self, next: &'a mut T) -> Self {
13939        unsafe {
13940            let next_ptr = <*mut T>::cast(next);
13941            let last_next = ptr_chain_iter(next).last().unwrap();
13942            (*last_next).p_next = self.inner.p_next as _;
13943            self.inner.p_next = next_ptr;
13944        }
13945        self
13946    }
13947    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13948    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13949    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
13950    pub fn build(self) -> QueueFamilyProperties2 {
13951        self.inner
13952    }
13953}
13954#[repr(C)]
13955#[cfg_attr(feature = "debug", derive(Debug))]
13956#[derive(Copy, Clone)]
13957#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html>"]
13958pub struct PhysicalDeviceMemoryProperties2 {
13959    pub s_type: StructureType,
13960    pub p_next: *mut c_void,
13961    pub memory_properties: PhysicalDeviceMemoryProperties,
13962}
13963impl ::std::default::Default for PhysicalDeviceMemoryProperties2 {
13964    fn default() -> Self {
13965        Self {
13966            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
13967            p_next: ::std::ptr::null_mut(),
13968            memory_properties: PhysicalDeviceMemoryProperties::default(),
13969        }
13970    }
13971}
13972impl PhysicalDeviceMemoryProperties2 {
13973    pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> {
13974        PhysicalDeviceMemoryProperties2Builder {
13975            inner: Self::default(),
13976            marker: ::std::marker::PhantomData,
13977        }
13978    }
13979}
13980#[repr(transparent)]
13981pub struct PhysicalDeviceMemoryProperties2Builder<'a> {
13982    inner: PhysicalDeviceMemoryProperties2,
13983    marker: ::std::marker::PhantomData<&'a ()>,
13984}
13985pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {}
13986impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> {
13987    type Target = PhysicalDeviceMemoryProperties2;
13988    fn deref(&self) -> &Self::Target {
13989        &self.inner
13990    }
13991}
13992impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> {
13993    fn deref_mut(&mut self) -> &mut Self::Target {
13994        &mut self.inner
13995    }
13996}
13997impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
13998    pub fn memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self {
13999        self.inner.memory_properties = memory_properties;
14000        self
14001    }
14002    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14003    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14004    #[doc = r" valid extension structs can be pushed into the chain."]
14005    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14006    #[doc = r" chain will look like `A -> D -> B -> C`."]
14007    pub fn push_next<T: ExtendsPhysicalDeviceMemoryProperties2>(mut self, next: &'a mut T) -> Self {
14008        unsafe {
14009            let next_ptr = <*mut T>::cast(next);
14010            let last_next = ptr_chain_iter(next).last().unwrap();
14011            (*last_next).p_next = self.inner.p_next as _;
14012            self.inner.p_next = next_ptr;
14013        }
14014        self
14015    }
14016    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14017    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14018    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14019    pub fn build(self) -> PhysicalDeviceMemoryProperties2 {
14020        self.inner
14021    }
14022}
14023#[repr(C)]
14024#[cfg_attr(feature = "debug", derive(Debug))]
14025#[derive(Copy, Clone)]
14026#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties2.html>"]
14027pub struct SparseImageFormatProperties2 {
14028    pub s_type: StructureType,
14029    pub p_next: *mut c_void,
14030    pub properties: SparseImageFormatProperties,
14031}
14032impl ::std::default::Default for SparseImageFormatProperties2 {
14033    fn default() -> Self {
14034        Self {
14035            s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2,
14036            p_next: ::std::ptr::null_mut(),
14037            properties: SparseImageFormatProperties::default(),
14038        }
14039    }
14040}
14041impl SparseImageFormatProperties2 {
14042    pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> {
14043        SparseImageFormatProperties2Builder {
14044            inner: Self::default(),
14045            marker: ::std::marker::PhantomData,
14046        }
14047    }
14048}
14049#[repr(transparent)]
14050pub struct SparseImageFormatProperties2Builder<'a> {
14051    inner: SparseImageFormatProperties2,
14052    marker: ::std::marker::PhantomData<&'a ()>,
14053}
14054impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> {
14055    type Target = SparseImageFormatProperties2;
14056    fn deref(&self) -> &Self::Target {
14057        &self.inner
14058    }
14059}
14060impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> {
14061    fn deref_mut(&mut self) -> &mut Self::Target {
14062        &mut self.inner
14063    }
14064}
14065impl<'a> SparseImageFormatProperties2Builder<'a> {
14066    pub fn properties(mut self, properties: SparseImageFormatProperties) -> Self {
14067        self.inner.properties = properties;
14068        self
14069    }
14070    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14071    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14072    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14073    pub fn build(self) -> SparseImageFormatProperties2 {
14074        self.inner
14075    }
14076}
14077#[repr(C)]
14078#[cfg_attr(feature = "debug", derive(Debug))]
14079#[derive(Copy, Clone)]
14080#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>"]
14081pub struct PhysicalDeviceSparseImageFormatInfo2 {
14082    pub s_type: StructureType,
14083    pub p_next: *const c_void,
14084    pub format: Format,
14085    pub ty: ImageType,
14086    pub samples: SampleCountFlags,
14087    pub usage: ImageUsageFlags,
14088    pub tiling: ImageTiling,
14089}
14090impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 {
14091    fn default() -> Self {
14092        Self {
14093            s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
14094            p_next: ::std::ptr::null(),
14095            format: Format::default(),
14096            ty: ImageType::default(),
14097            samples: SampleCountFlags::default(),
14098            usage: ImageUsageFlags::default(),
14099            tiling: ImageTiling::default(),
14100        }
14101    }
14102}
14103impl PhysicalDeviceSparseImageFormatInfo2 {
14104    pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14105        PhysicalDeviceSparseImageFormatInfo2Builder {
14106            inner: Self::default(),
14107            marker: ::std::marker::PhantomData,
14108        }
14109    }
14110}
14111#[repr(transparent)]
14112pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14113    inner: PhysicalDeviceSparseImageFormatInfo2,
14114    marker: ::std::marker::PhantomData<&'a ()>,
14115}
14116impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14117    type Target = PhysicalDeviceSparseImageFormatInfo2;
14118    fn deref(&self) -> &Self::Target {
14119        &self.inner
14120    }
14121}
14122impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14123    fn deref_mut(&mut self) -> &mut Self::Target {
14124        &mut self.inner
14125    }
14126}
14127impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
14128    pub fn format(mut self, format: Format) -> Self {
14129        self.inner.format = format;
14130        self
14131    }
14132    pub fn ty(mut self, ty: ImageType) -> Self {
14133        self.inner.ty = ty;
14134        self
14135    }
14136    pub fn samples(mut self, samples: SampleCountFlags) -> Self {
14137        self.inner.samples = samples;
14138        self
14139    }
14140    pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
14141        self.inner.usage = usage;
14142        self
14143    }
14144    pub fn tiling(mut self, tiling: ImageTiling) -> Self {
14145        self.inner.tiling = tiling;
14146        self
14147    }
14148    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14149    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14150    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14151    pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 {
14152        self.inner
14153    }
14154}
14155#[repr(C)]
14156#[cfg_attr(feature = "debug", derive(Debug))]
14157#[derive(Copy, Clone)]
14158#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>"]
14159pub struct PhysicalDevicePushDescriptorPropertiesKHR {
14160    pub s_type: StructureType,
14161    pub p_next: *mut c_void,
14162    pub max_push_descriptors: u32,
14163}
14164impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR {
14165    fn default() -> Self {
14166        Self {
14167            s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
14168            p_next: ::std::ptr::null_mut(),
14169            max_push_descriptors: u32::default(),
14170        }
14171    }
14172}
14173impl PhysicalDevicePushDescriptorPropertiesKHR {
14174    pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14175        PhysicalDevicePushDescriptorPropertiesKHRBuilder {
14176            inner: Self::default(),
14177            marker: ::std::marker::PhantomData,
14178        }
14179    }
14180}
14181#[repr(transparent)]
14182pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14183    inner: PhysicalDevicePushDescriptorPropertiesKHR,
14184    marker: ::std::marker::PhantomData<&'a ()>,
14185}
14186unsafe impl ExtendsPhysicalDeviceProperties2
14187    for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_>
14188{
14189}
14190unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {}
14191impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14192    type Target = PhysicalDevicePushDescriptorPropertiesKHR;
14193    fn deref(&self) -> &Self::Target {
14194        &self.inner
14195    }
14196}
14197impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14198    fn deref_mut(&mut self) -> &mut Self::Target {
14199        &mut self.inner
14200    }
14201}
14202impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
14203    pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self {
14204        self.inner.max_push_descriptors = max_push_descriptors;
14205        self
14206    }
14207    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14208    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14209    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14210    pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR {
14211        self.inner
14212    }
14213}
14214#[repr(C)]
14215#[cfg_attr(feature = "debug", derive(Debug))]
14216#[derive(Copy, Clone, Default)]
14217#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConformanceVersion.html>"]
14218pub struct ConformanceVersion {
14219    pub major: u8,
14220    pub minor: u8,
14221    pub subminor: u8,
14222    pub patch: u8,
14223}
14224impl ConformanceVersion {
14225    pub fn builder<'a>() -> ConformanceVersionBuilder<'a> {
14226        ConformanceVersionBuilder {
14227            inner: Self::default(),
14228            marker: ::std::marker::PhantomData,
14229        }
14230    }
14231}
14232#[repr(transparent)]
14233pub struct ConformanceVersionBuilder<'a> {
14234    inner: ConformanceVersion,
14235    marker: ::std::marker::PhantomData<&'a ()>,
14236}
14237impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> {
14238    type Target = ConformanceVersion;
14239    fn deref(&self) -> &Self::Target {
14240        &self.inner
14241    }
14242}
14243impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> {
14244    fn deref_mut(&mut self) -> &mut Self::Target {
14245        &mut self.inner
14246    }
14247}
14248impl<'a> ConformanceVersionBuilder<'a> {
14249    pub fn major(mut self, major: u8) -> Self {
14250        self.inner.major = major;
14251        self
14252    }
14253    pub fn minor(mut self, minor: u8) -> Self {
14254        self.inner.minor = minor;
14255        self
14256    }
14257    pub fn subminor(mut self, subminor: u8) -> Self {
14258        self.inner.subminor = subminor;
14259        self
14260    }
14261    pub fn patch(mut self, patch: u8) -> Self {
14262        self.inner.patch = patch;
14263        self
14264    }
14265    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14266    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14267    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14268    pub fn build(self) -> ConformanceVersion {
14269        self.inner
14270    }
14271}
14272#[repr(C)]
14273#[derive(Copy, Clone)]
14274#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDriverProperties.html>"]
14275pub struct PhysicalDeviceDriverProperties {
14276    pub s_type: StructureType,
14277    pub p_next: *mut c_void,
14278    pub driver_id: DriverId,
14279    pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
14280    pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
14281    pub conformance_version: ConformanceVersion,
14282}
14283#[cfg(feature = "debug")]
14284impl fmt::Debug for PhysicalDeviceDriverProperties {
14285    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
14286        fmt.debug_struct("PhysicalDeviceDriverProperties")
14287            .field("s_type", &self.s_type)
14288            .field("p_next", &self.p_next)
14289            .field("driver_id", &self.driver_id)
14290            .field("driver_name", &unsafe {
14291                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
14292            })
14293            .field("driver_info", &unsafe {
14294                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
14295            })
14296            .field("conformance_version", &self.conformance_version)
14297            .finish()
14298    }
14299}
14300impl ::std::default::Default for PhysicalDeviceDriverProperties {
14301    fn default() -> Self {
14302        Self {
14303            s_type: StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES,
14304            p_next: ::std::ptr::null_mut(),
14305            driver_id: DriverId::default(),
14306            driver_name: unsafe { ::std::mem::zeroed() },
14307            driver_info: unsafe { ::std::mem::zeroed() },
14308            conformance_version: ConformanceVersion::default(),
14309        }
14310    }
14311}
14312impl PhysicalDeviceDriverProperties {
14313    pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> {
14314        PhysicalDeviceDriverPropertiesBuilder {
14315            inner: Self::default(),
14316            marker: ::std::marker::PhantomData,
14317        }
14318    }
14319}
14320#[repr(transparent)]
14321pub struct PhysicalDeviceDriverPropertiesBuilder<'a> {
14322    inner: PhysicalDeviceDriverProperties,
14323    marker: ::std::marker::PhantomData<&'a ()>,
14324}
14325unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {}
14326unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {}
14327impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> {
14328    type Target = PhysicalDeviceDriverProperties;
14329    fn deref(&self) -> &Self::Target {
14330        &self.inner
14331    }
14332}
14333impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> {
14334    fn deref_mut(&mut self) -> &mut Self::Target {
14335        &mut self.inner
14336    }
14337}
14338impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
14339    pub fn driver_id(mut self, driver_id: DriverId) -> Self {
14340        self.inner.driver_id = driver_id;
14341        self
14342    }
14343    pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
14344        self.inner.driver_name = driver_name;
14345        self
14346    }
14347    pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
14348        self.inner.driver_info = driver_info;
14349        self
14350    }
14351    pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
14352        self.inner.conformance_version = conformance_version;
14353        self
14354    }
14355    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14356    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14357    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14358    pub fn build(self) -> PhysicalDeviceDriverProperties {
14359        self.inner
14360    }
14361}
14362#[repr(C)]
14363#[cfg_attr(feature = "debug", derive(Debug))]
14364#[derive(Copy, Clone)]
14365#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionsKHR.html>"]
14366pub struct PresentRegionsKHR {
14367    pub s_type: StructureType,
14368    pub p_next: *const c_void,
14369    pub swapchain_count: u32,
14370    pub p_regions: *const PresentRegionKHR,
14371}
14372impl ::std::default::Default for PresentRegionsKHR {
14373    fn default() -> Self {
14374        Self {
14375            s_type: StructureType::PRESENT_REGIONS_KHR,
14376            p_next: ::std::ptr::null(),
14377            swapchain_count: u32::default(),
14378            p_regions: ::std::ptr::null(),
14379        }
14380    }
14381}
14382impl PresentRegionsKHR {
14383    pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> {
14384        PresentRegionsKHRBuilder {
14385            inner: Self::default(),
14386            marker: ::std::marker::PhantomData,
14387        }
14388    }
14389}
14390#[repr(transparent)]
14391pub struct PresentRegionsKHRBuilder<'a> {
14392    inner: PresentRegionsKHR,
14393    marker: ::std::marker::PhantomData<&'a ()>,
14394}
14395unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {}
14396unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {}
14397impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> {
14398    type Target = PresentRegionsKHR;
14399    fn deref(&self) -> &Self::Target {
14400        &self.inner
14401    }
14402}
14403impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> {
14404    fn deref_mut(&mut self) -> &mut Self::Target {
14405        &mut self.inner
14406    }
14407}
14408impl<'a> PresentRegionsKHRBuilder<'a> {
14409    pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> Self {
14410        self.inner.swapchain_count = regions.len() as _;
14411        self.inner.p_regions = regions.as_ptr();
14412        self
14413    }
14414    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14415    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14416    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14417    pub fn build(self) -> PresentRegionsKHR {
14418        self.inner
14419    }
14420}
14421#[repr(C)]
14422#[cfg_attr(feature = "debug", derive(Debug))]
14423#[derive(Copy, Clone)]
14424#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionKHR.html>"]
14425pub struct PresentRegionKHR {
14426    pub rectangle_count: u32,
14427    pub p_rectangles: *const RectLayerKHR,
14428}
14429impl ::std::default::Default for PresentRegionKHR {
14430    fn default() -> Self {
14431        Self {
14432            rectangle_count: u32::default(),
14433            p_rectangles: ::std::ptr::null(),
14434        }
14435    }
14436}
14437impl PresentRegionKHR {
14438    pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> {
14439        PresentRegionKHRBuilder {
14440            inner: Self::default(),
14441            marker: ::std::marker::PhantomData,
14442        }
14443    }
14444}
14445#[repr(transparent)]
14446pub struct PresentRegionKHRBuilder<'a> {
14447    inner: PresentRegionKHR,
14448    marker: ::std::marker::PhantomData<&'a ()>,
14449}
14450impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> {
14451    type Target = PresentRegionKHR;
14452    fn deref(&self) -> &Self::Target {
14453        &self.inner
14454    }
14455}
14456impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> {
14457    fn deref_mut(&mut self) -> &mut Self::Target {
14458        &mut self.inner
14459    }
14460}
14461impl<'a> PresentRegionKHRBuilder<'a> {
14462    pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self {
14463        self.inner.rectangle_count = rectangles.len() as _;
14464        self.inner.p_rectangles = rectangles.as_ptr();
14465        self
14466    }
14467    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14468    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14469    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14470    pub fn build(self) -> PresentRegionKHR {
14471        self.inner
14472    }
14473}
14474#[repr(C)]
14475#[cfg_attr(feature = "debug", derive(Debug))]
14476#[derive(Copy, Clone, Default)]
14477#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRectLayerKHR.html>"]
14478pub struct RectLayerKHR {
14479    pub offset: Offset2D,
14480    pub extent: Extent2D,
14481    pub layer: u32,
14482}
14483impl RectLayerKHR {
14484    pub fn builder<'a>() -> RectLayerKHRBuilder<'a> {
14485        RectLayerKHRBuilder {
14486            inner: Self::default(),
14487            marker: ::std::marker::PhantomData,
14488        }
14489    }
14490}
14491#[repr(transparent)]
14492pub struct RectLayerKHRBuilder<'a> {
14493    inner: RectLayerKHR,
14494    marker: ::std::marker::PhantomData<&'a ()>,
14495}
14496impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> {
14497    type Target = RectLayerKHR;
14498    fn deref(&self) -> &Self::Target {
14499        &self.inner
14500    }
14501}
14502impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> {
14503    fn deref_mut(&mut self) -> &mut Self::Target {
14504        &mut self.inner
14505    }
14506}
14507impl<'a> RectLayerKHRBuilder<'a> {
14508    pub fn offset(mut self, offset: Offset2D) -> Self {
14509        self.inner.offset = offset;
14510        self
14511    }
14512    pub fn extent(mut self, extent: Extent2D) -> Self {
14513        self.inner.extent = extent;
14514        self
14515    }
14516    pub fn layer(mut self, layer: u32) -> Self {
14517        self.inner.layer = layer;
14518        self
14519    }
14520    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14521    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14522    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14523    pub fn build(self) -> RectLayerKHR {
14524        self.inner
14525    }
14526}
14527#[repr(C)]
14528#[cfg_attr(feature = "debug", derive(Debug))]
14529#[derive(Copy, Clone)]
14530#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html>"]
14531pub struct PhysicalDeviceVariablePointersFeatures {
14532    pub s_type: StructureType,
14533    pub p_next: *mut c_void,
14534    pub variable_pointers_storage_buffer: Bool32,
14535    pub variable_pointers: Bool32,
14536}
14537impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures {
14538    fn default() -> Self {
14539        Self {
14540            s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
14541            p_next: ::std::ptr::null_mut(),
14542            variable_pointers_storage_buffer: Bool32::default(),
14543            variable_pointers: Bool32::default(),
14544        }
14545    }
14546}
14547impl PhysicalDeviceVariablePointersFeatures {
14548    pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14549        PhysicalDeviceVariablePointersFeaturesBuilder {
14550            inner: Self::default(),
14551            marker: ::std::marker::PhantomData,
14552        }
14553    }
14554}
14555#[repr(transparent)]
14556pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14557    inner: PhysicalDeviceVariablePointersFeatures,
14558    marker: ::std::marker::PhantomData<&'a ()>,
14559}
14560unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
14561unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures {}
14562unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
14563unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {}
14564impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14565    type Target = PhysicalDeviceVariablePointersFeatures;
14566    fn deref(&self) -> &Self::Target {
14567        &self.inner
14568    }
14569}
14570impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14571    fn deref_mut(&mut self) -> &mut Self::Target {
14572        &mut self.inner
14573    }
14574}
14575impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
14576    pub fn variable_pointers_storage_buffer(
14577        mut self,
14578        variable_pointers_storage_buffer: bool,
14579    ) -> Self {
14580        self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
14581        self
14582    }
14583    pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
14584        self.inner.variable_pointers = variable_pointers.into();
14585        self
14586    }
14587    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14588    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14589    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14590    pub fn build(self) -> PhysicalDeviceVariablePointersFeatures {
14591        self.inner
14592    }
14593}
14594#[repr(C)]
14595#[cfg_attr(feature = "debug", derive(Debug))]
14596#[derive(Copy, Clone, Default)]
14597#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryProperties.html>"]
14598pub struct ExternalMemoryProperties {
14599    pub external_memory_features: ExternalMemoryFeatureFlags,
14600    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
14601    pub compatible_handle_types: ExternalMemoryHandleTypeFlags,
14602}
14603impl ExternalMemoryProperties {
14604    pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> {
14605        ExternalMemoryPropertiesBuilder {
14606            inner: Self::default(),
14607            marker: ::std::marker::PhantomData,
14608        }
14609    }
14610}
14611#[repr(transparent)]
14612pub struct ExternalMemoryPropertiesBuilder<'a> {
14613    inner: ExternalMemoryProperties,
14614    marker: ::std::marker::PhantomData<&'a ()>,
14615}
14616impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> {
14617    type Target = ExternalMemoryProperties;
14618    fn deref(&self) -> &Self::Target {
14619        &self.inner
14620    }
14621}
14622impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> {
14623    fn deref_mut(&mut self) -> &mut Self::Target {
14624        &mut self.inner
14625    }
14626}
14627impl<'a> ExternalMemoryPropertiesBuilder<'a> {
14628    pub fn external_memory_features(
14629        mut self,
14630        external_memory_features: ExternalMemoryFeatureFlags,
14631    ) -> Self {
14632        self.inner.external_memory_features = external_memory_features;
14633        self
14634    }
14635    pub fn export_from_imported_handle_types(
14636        mut self,
14637        export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
14638    ) -> Self {
14639        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
14640        self
14641    }
14642    pub fn compatible_handle_types(
14643        mut self,
14644        compatible_handle_types: ExternalMemoryHandleTypeFlags,
14645    ) -> Self {
14646        self.inner.compatible_handle_types = compatible_handle_types;
14647        self
14648    }
14649    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14650    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14651    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14652    pub fn build(self) -> ExternalMemoryProperties {
14653        self.inner
14654    }
14655}
14656#[repr(C)]
14657#[cfg_attr(feature = "debug", derive(Debug))]
14658#[derive(Copy, Clone)]
14659#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>"]
14660pub struct PhysicalDeviceExternalImageFormatInfo {
14661    pub s_type: StructureType,
14662    pub p_next: *const c_void,
14663    pub handle_type: ExternalMemoryHandleTypeFlags,
14664}
14665impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo {
14666    fn default() -> Self {
14667        Self {
14668            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
14669            p_next: ::std::ptr::null(),
14670            handle_type: ExternalMemoryHandleTypeFlags::default(),
14671        }
14672    }
14673}
14674impl PhysicalDeviceExternalImageFormatInfo {
14675    pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14676        PhysicalDeviceExternalImageFormatInfoBuilder {
14677            inner: Self::default(),
14678            marker: ::std::marker::PhantomData,
14679        }
14680    }
14681}
14682#[repr(transparent)]
14683pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14684    inner: PhysicalDeviceExternalImageFormatInfo,
14685    marker: ::std::marker::PhantomData<&'a ()>,
14686}
14687unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
14688    for PhysicalDeviceExternalImageFormatInfoBuilder<'_>
14689{
14690}
14691unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {}
14692impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14693    type Target = PhysicalDeviceExternalImageFormatInfo;
14694    fn deref(&self) -> &Self::Target {
14695        &self.inner
14696    }
14697}
14698impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14699    fn deref_mut(&mut self) -> &mut Self::Target {
14700        &mut self.inner
14701    }
14702}
14703impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
14704    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
14705        self.inner.handle_type = handle_type;
14706        self
14707    }
14708    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14709    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14710    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14711    pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo {
14712        self.inner
14713    }
14714}
14715#[repr(C)]
14716#[cfg_attr(feature = "debug", derive(Debug))]
14717#[derive(Copy, Clone)]
14718#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatProperties.html>"]
14719pub struct ExternalImageFormatProperties {
14720    pub s_type: StructureType,
14721    pub p_next: *mut c_void,
14722    pub external_memory_properties: ExternalMemoryProperties,
14723}
14724impl ::std::default::Default for ExternalImageFormatProperties {
14725    fn default() -> Self {
14726        Self {
14727            s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES,
14728            p_next: ::std::ptr::null_mut(),
14729            external_memory_properties: ExternalMemoryProperties::default(),
14730        }
14731    }
14732}
14733impl ExternalImageFormatProperties {
14734    pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> {
14735        ExternalImageFormatPropertiesBuilder {
14736            inner: Self::default(),
14737            marker: ::std::marker::PhantomData,
14738        }
14739    }
14740}
14741#[repr(transparent)]
14742pub struct ExternalImageFormatPropertiesBuilder<'a> {
14743    inner: ExternalImageFormatProperties,
14744    marker: ::std::marker::PhantomData<&'a ()>,
14745}
14746unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {}
14747unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {}
14748impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> {
14749    type Target = ExternalImageFormatProperties;
14750    fn deref(&self) -> &Self::Target {
14751        &self.inner
14752    }
14753}
14754impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> {
14755    fn deref_mut(&mut self) -> &mut Self::Target {
14756        &mut self.inner
14757    }
14758}
14759impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
14760    pub fn external_memory_properties(
14761        mut self,
14762        external_memory_properties: ExternalMemoryProperties,
14763    ) -> Self {
14764        self.inner.external_memory_properties = external_memory_properties;
14765        self
14766    }
14767    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14768    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14769    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14770    pub fn build(self) -> ExternalImageFormatProperties {
14771        self.inner
14772    }
14773}
14774#[repr(C)]
14775#[cfg_attr(feature = "debug", derive(Debug))]
14776#[derive(Copy, Clone)]
14777#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html>"]
14778pub struct PhysicalDeviceExternalBufferInfo {
14779    pub s_type: StructureType,
14780    pub p_next: *const c_void,
14781    pub flags: BufferCreateFlags,
14782    pub usage: BufferUsageFlags,
14783    pub handle_type: ExternalMemoryHandleTypeFlags,
14784}
14785impl ::std::default::Default for PhysicalDeviceExternalBufferInfo {
14786    fn default() -> Self {
14787        Self {
14788            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
14789            p_next: ::std::ptr::null(),
14790            flags: BufferCreateFlags::default(),
14791            usage: BufferUsageFlags::default(),
14792            handle_type: ExternalMemoryHandleTypeFlags::default(),
14793        }
14794    }
14795}
14796impl PhysicalDeviceExternalBufferInfo {
14797    pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
14798        PhysicalDeviceExternalBufferInfoBuilder {
14799            inner: Self::default(),
14800            marker: ::std::marker::PhantomData,
14801        }
14802    }
14803}
14804#[repr(transparent)]
14805pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> {
14806    inner: PhysicalDeviceExternalBufferInfo,
14807    marker: ::std::marker::PhantomData<&'a ()>,
14808}
14809impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> {
14810    type Target = PhysicalDeviceExternalBufferInfo;
14811    fn deref(&self) -> &Self::Target {
14812        &self.inner
14813    }
14814}
14815impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> {
14816    fn deref_mut(&mut self) -> &mut Self::Target {
14817        &mut self.inner
14818    }
14819}
14820impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
14821    pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
14822        self.inner.flags = flags;
14823        self
14824    }
14825    pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
14826        self.inner.usage = usage;
14827        self
14828    }
14829    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
14830        self.inner.handle_type = handle_type;
14831        self
14832    }
14833    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14834    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14835    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14836    pub fn build(self) -> PhysicalDeviceExternalBufferInfo {
14837        self.inner
14838    }
14839}
14840#[repr(C)]
14841#[cfg_attr(feature = "debug", derive(Debug))]
14842#[derive(Copy, Clone)]
14843#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalBufferProperties.html>"]
14844pub struct ExternalBufferProperties {
14845    pub s_type: StructureType,
14846    pub p_next: *mut c_void,
14847    pub external_memory_properties: ExternalMemoryProperties,
14848}
14849impl ::std::default::Default for ExternalBufferProperties {
14850    fn default() -> Self {
14851        Self {
14852            s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES,
14853            p_next: ::std::ptr::null_mut(),
14854            external_memory_properties: ExternalMemoryProperties::default(),
14855        }
14856    }
14857}
14858impl ExternalBufferProperties {
14859    pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> {
14860        ExternalBufferPropertiesBuilder {
14861            inner: Self::default(),
14862            marker: ::std::marker::PhantomData,
14863        }
14864    }
14865}
14866#[repr(transparent)]
14867pub struct ExternalBufferPropertiesBuilder<'a> {
14868    inner: ExternalBufferProperties,
14869    marker: ::std::marker::PhantomData<&'a ()>,
14870}
14871impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> {
14872    type Target = ExternalBufferProperties;
14873    fn deref(&self) -> &Self::Target {
14874        &self.inner
14875    }
14876}
14877impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> {
14878    fn deref_mut(&mut self) -> &mut Self::Target {
14879        &mut self.inner
14880    }
14881}
14882impl<'a> ExternalBufferPropertiesBuilder<'a> {
14883    pub fn external_memory_properties(
14884        mut self,
14885        external_memory_properties: ExternalMemoryProperties,
14886    ) -> Self {
14887        self.inner.external_memory_properties = external_memory_properties;
14888        self
14889    }
14890    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14891    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14892    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14893    pub fn build(self) -> ExternalBufferProperties {
14894        self.inner
14895    }
14896}
14897#[repr(C)]
14898#[cfg_attr(feature = "debug", derive(Debug))]
14899#[derive(Copy, Clone)]
14900#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIDProperties.html>"]
14901pub struct PhysicalDeviceIDProperties {
14902    pub s_type: StructureType,
14903    pub p_next: *mut c_void,
14904    pub device_uuid: [u8; UUID_SIZE],
14905    pub driver_uuid: [u8; UUID_SIZE],
14906    pub device_luid: [u8; LUID_SIZE],
14907    pub device_node_mask: u32,
14908    pub device_luid_valid: Bool32,
14909}
14910impl ::std::default::Default for PhysicalDeviceIDProperties {
14911    fn default() -> Self {
14912        Self {
14913            s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES,
14914            p_next: ::std::ptr::null_mut(),
14915            device_uuid: unsafe { ::std::mem::zeroed() },
14916            driver_uuid: unsafe { ::std::mem::zeroed() },
14917            device_luid: unsafe { ::std::mem::zeroed() },
14918            device_node_mask: u32::default(),
14919            device_luid_valid: Bool32::default(),
14920        }
14921    }
14922}
14923impl PhysicalDeviceIDProperties {
14924    pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> {
14925        PhysicalDeviceIDPropertiesBuilder {
14926            inner: Self::default(),
14927            marker: ::std::marker::PhantomData,
14928        }
14929    }
14930}
14931#[repr(transparent)]
14932pub struct PhysicalDeviceIDPropertiesBuilder<'a> {
14933    inner: PhysicalDeviceIDProperties,
14934    marker: ::std::marker::PhantomData<&'a ()>,
14935}
14936unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {}
14937unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {}
14938impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> {
14939    type Target = PhysicalDeviceIDProperties;
14940    fn deref(&self) -> &Self::Target {
14941        &self.inner
14942    }
14943}
14944impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> {
14945    fn deref_mut(&mut self) -> &mut Self::Target {
14946        &mut self.inner
14947    }
14948}
14949impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
14950    pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
14951        self.inner.device_uuid = device_uuid;
14952        self
14953    }
14954    pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
14955        self.inner.driver_uuid = driver_uuid;
14956        self
14957    }
14958    pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
14959        self.inner.device_luid = device_luid;
14960        self
14961    }
14962    pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
14963        self.inner.device_node_mask = device_node_mask;
14964        self
14965    }
14966    pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
14967        self.inner.device_luid_valid = device_luid_valid.into();
14968        self
14969    }
14970    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14971    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14972    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
14973    pub fn build(self) -> PhysicalDeviceIDProperties {
14974        self.inner
14975    }
14976}
14977#[repr(C)]
14978#[cfg_attr(feature = "debug", derive(Debug))]
14979#[derive(Copy, Clone)]
14980#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfo.html>"]
14981pub struct ExternalMemoryImageCreateInfo {
14982    pub s_type: StructureType,
14983    pub p_next: *const c_void,
14984    pub handle_types: ExternalMemoryHandleTypeFlags,
14985}
14986impl ::std::default::Default for ExternalMemoryImageCreateInfo {
14987    fn default() -> Self {
14988        Self {
14989            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
14990            p_next: ::std::ptr::null(),
14991            handle_types: ExternalMemoryHandleTypeFlags::default(),
14992        }
14993    }
14994}
14995impl ExternalMemoryImageCreateInfo {
14996    pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> {
14997        ExternalMemoryImageCreateInfoBuilder {
14998            inner: Self::default(),
14999            marker: ::std::marker::PhantomData,
15000        }
15001    }
15002}
15003#[repr(transparent)]
15004pub struct ExternalMemoryImageCreateInfoBuilder<'a> {
15005    inner: ExternalMemoryImageCreateInfo,
15006    marker: ::std::marker::PhantomData<&'a ()>,
15007}
15008unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {}
15009unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {}
15010impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> {
15011    type Target = ExternalMemoryImageCreateInfo;
15012    fn deref(&self) -> &Self::Target {
15013        &self.inner
15014    }
15015}
15016impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> {
15017    fn deref_mut(&mut self) -> &mut Self::Target {
15018        &mut self.inner
15019    }
15020}
15021impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
15022    pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
15023        self.inner.handle_types = handle_types;
15024        self
15025    }
15026    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15027    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15028    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15029    pub fn build(self) -> ExternalMemoryImageCreateInfo {
15030        self.inner
15031    }
15032}
15033#[repr(C)]
15034#[cfg_attr(feature = "debug", derive(Debug))]
15035#[derive(Copy, Clone)]
15036#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryBufferCreateInfo.html>"]
15037pub struct ExternalMemoryBufferCreateInfo {
15038    pub s_type: StructureType,
15039    pub p_next: *const c_void,
15040    pub handle_types: ExternalMemoryHandleTypeFlags,
15041}
15042impl ::std::default::Default for ExternalMemoryBufferCreateInfo {
15043    fn default() -> Self {
15044        Self {
15045            s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
15046            p_next: ::std::ptr::null(),
15047            handle_types: ExternalMemoryHandleTypeFlags::default(),
15048        }
15049    }
15050}
15051impl ExternalMemoryBufferCreateInfo {
15052    pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> {
15053        ExternalMemoryBufferCreateInfoBuilder {
15054            inner: Self::default(),
15055            marker: ::std::marker::PhantomData,
15056        }
15057    }
15058}
15059#[repr(transparent)]
15060pub struct ExternalMemoryBufferCreateInfoBuilder<'a> {
15061    inner: ExternalMemoryBufferCreateInfo,
15062    marker: ::std::marker::PhantomData<&'a ()>,
15063}
15064unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {}
15065unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {}
15066impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> {
15067    type Target = ExternalMemoryBufferCreateInfo;
15068    fn deref(&self) -> &Self::Target {
15069        &self.inner
15070    }
15071}
15072impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> {
15073    fn deref_mut(&mut self) -> &mut Self::Target {
15074        &mut self.inner
15075    }
15076}
15077impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
15078    pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
15079        self.inner.handle_types = handle_types;
15080        self
15081    }
15082    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15083    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15084    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15085    pub fn build(self) -> ExternalMemoryBufferCreateInfo {
15086        self.inner
15087    }
15088}
15089#[repr(C)]
15090#[cfg_attr(feature = "debug", derive(Debug))]
15091#[derive(Copy, Clone)]
15092#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfo.html>"]
15093pub struct ExportMemoryAllocateInfo {
15094    pub s_type: StructureType,
15095    pub p_next: *const c_void,
15096    pub handle_types: ExternalMemoryHandleTypeFlags,
15097}
15098impl ::std::default::Default for ExportMemoryAllocateInfo {
15099    fn default() -> Self {
15100        Self {
15101            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO,
15102            p_next: ::std::ptr::null(),
15103            handle_types: ExternalMemoryHandleTypeFlags::default(),
15104        }
15105    }
15106}
15107impl ExportMemoryAllocateInfo {
15108    pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> {
15109        ExportMemoryAllocateInfoBuilder {
15110            inner: Self::default(),
15111            marker: ::std::marker::PhantomData,
15112        }
15113    }
15114}
15115#[repr(transparent)]
15116pub struct ExportMemoryAllocateInfoBuilder<'a> {
15117    inner: ExportMemoryAllocateInfo,
15118    marker: ::std::marker::PhantomData<&'a ()>,
15119}
15120unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {}
15121unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {}
15122impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> {
15123    type Target = ExportMemoryAllocateInfo;
15124    fn deref(&self) -> &Self::Target {
15125        &self.inner
15126    }
15127}
15128impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> {
15129    fn deref_mut(&mut self) -> &mut Self::Target {
15130        &mut self.inner
15131    }
15132}
15133impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
15134    pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
15135        self.inner.handle_types = handle_types;
15136        self
15137    }
15138    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15139    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15140    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15141    pub fn build(self) -> ExportMemoryAllocateInfo {
15142        self.inner
15143    }
15144}
15145#[repr(C)]
15146#[cfg_attr(feature = "debug", derive(Debug))]
15147#[derive(Copy, Clone)]
15148#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html>"]
15149pub struct ImportMemoryWin32HandleInfoKHR {
15150    pub s_type: StructureType,
15151    pub p_next: *const c_void,
15152    pub handle_type: ExternalMemoryHandleTypeFlags,
15153    pub handle: HANDLE,
15154    pub name: LPCWSTR,
15155}
15156impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR {
15157    fn default() -> Self {
15158        Self {
15159            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
15160            p_next: ::std::ptr::null(),
15161            handle_type: ExternalMemoryHandleTypeFlags::default(),
15162            handle: unsafe { ::std::mem::zeroed() },
15163            name: unsafe { ::std::mem::zeroed() },
15164        }
15165    }
15166}
15167impl ImportMemoryWin32HandleInfoKHR {
15168    pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15169        ImportMemoryWin32HandleInfoKHRBuilder {
15170            inner: Self::default(),
15171            marker: ::std::marker::PhantomData,
15172        }
15173    }
15174}
15175#[repr(transparent)]
15176pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15177    inner: ImportMemoryWin32HandleInfoKHR,
15178    marker: ::std::marker::PhantomData<&'a ()>,
15179}
15180unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {}
15181unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {}
15182impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15183    type Target = ImportMemoryWin32HandleInfoKHR;
15184    fn deref(&self) -> &Self::Target {
15185        &self.inner
15186    }
15187}
15188impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15189    fn deref_mut(&mut self) -> &mut Self::Target {
15190        &mut self.inner
15191    }
15192}
15193impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
15194    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15195        self.inner.handle_type = handle_type;
15196        self
15197    }
15198    pub fn handle(mut self, handle: HANDLE) -> Self {
15199        self.inner.handle = handle;
15200        self
15201    }
15202    pub fn name(mut self, name: LPCWSTR) -> Self {
15203        self.inner.name = name;
15204        self
15205    }
15206    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15207    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15208    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15209    pub fn build(self) -> ImportMemoryWin32HandleInfoKHR {
15210        self.inner
15211    }
15212}
15213#[repr(C)]
15214#[cfg_attr(feature = "debug", derive(Debug))]
15215#[derive(Copy, Clone)]
15216#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html>"]
15217pub struct ExportMemoryWin32HandleInfoKHR {
15218    pub s_type: StructureType,
15219    pub p_next: *const c_void,
15220    pub p_attributes: *const SECURITY_ATTRIBUTES,
15221    pub dw_access: DWORD,
15222    pub name: LPCWSTR,
15223}
15224impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR {
15225    fn default() -> Self {
15226        Self {
15227            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
15228            p_next: ::std::ptr::null(),
15229            p_attributes: ::std::ptr::null(),
15230            dw_access: DWORD::default(),
15231            name: unsafe { ::std::mem::zeroed() },
15232        }
15233    }
15234}
15235impl ExportMemoryWin32HandleInfoKHR {
15236    pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15237        ExportMemoryWin32HandleInfoKHRBuilder {
15238            inner: Self::default(),
15239            marker: ::std::marker::PhantomData,
15240        }
15241    }
15242}
15243#[repr(transparent)]
15244pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15245    inner: ExportMemoryWin32HandleInfoKHR,
15246    marker: ::std::marker::PhantomData<&'a ()>,
15247}
15248unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {}
15249unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {}
15250impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15251    type Target = ExportMemoryWin32HandleInfoKHR;
15252    fn deref(&self) -> &Self::Target {
15253        &self.inner
15254    }
15255}
15256impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15257    fn deref_mut(&mut self) -> &mut Self::Target {
15258        &mut self.inner
15259    }
15260}
15261impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
15262    pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
15263        self.inner.p_attributes = attributes;
15264        self
15265    }
15266    pub fn dw_access(mut self, dw_access: DWORD) -> Self {
15267        self.inner.dw_access = dw_access;
15268        self
15269    }
15270    pub fn name(mut self, name: LPCWSTR) -> Self {
15271        self.inner.name = name;
15272        self
15273    }
15274    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15275    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15276    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15277    pub fn build(self) -> ExportMemoryWin32HandleInfoKHR {
15278        self.inner
15279    }
15280}
15281#[repr(C)]
15282#[cfg_attr(feature = "debug", derive(Debug))]
15283#[derive(Copy, Clone)]
15284#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html>"]
15285pub struct ImportMemoryZirconHandleInfoFUCHSIA {
15286    pub s_type: StructureType,
15287    pub p_next: *const c_void,
15288    pub handle_type: ExternalMemoryHandleTypeFlags,
15289    pub handle: zx_handle_t,
15290}
15291impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA {
15292    fn default() -> Self {
15293        Self {
15294            s_type: StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA,
15295            p_next: ::std::ptr::null(),
15296            handle_type: ExternalMemoryHandleTypeFlags::default(),
15297            handle: zx_handle_t::default(),
15298        }
15299    }
15300}
15301impl ImportMemoryZirconHandleInfoFUCHSIA {
15302    pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15303        ImportMemoryZirconHandleInfoFUCHSIABuilder {
15304            inner: Self::default(),
15305            marker: ::std::marker::PhantomData,
15306        }
15307    }
15308}
15309#[repr(transparent)]
15310pub struct ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15311    inner: ImportMemoryZirconHandleInfoFUCHSIA,
15312    marker: ::std::marker::PhantomData<&'a ()>,
15313}
15314unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIABuilder<'_> {}
15315unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA {}
15316impl<'a> ::std::ops::Deref for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15317    type Target = ImportMemoryZirconHandleInfoFUCHSIA;
15318    fn deref(&self) -> &Self::Target {
15319        &self.inner
15320    }
15321}
15322impl<'a> ::std::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15323    fn deref_mut(&mut self) -> &mut Self::Target {
15324        &mut self.inner
15325    }
15326}
15327impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
15328    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15329        self.inner.handle_type = handle_type;
15330        self
15331    }
15332    pub fn handle(mut self, handle: zx_handle_t) -> Self {
15333        self.inner.handle = handle;
15334        self
15335    }
15336    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15337    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15338    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15339    pub fn build(self) -> ImportMemoryZirconHandleInfoFUCHSIA {
15340        self.inner
15341    }
15342}
15343#[repr(C)]
15344#[cfg_attr(feature = "debug", derive(Debug))]
15345#[derive(Copy, Clone)]
15346#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html>"]
15347pub struct MemoryZirconHandlePropertiesFUCHSIA {
15348    pub s_type: StructureType,
15349    pub p_next: *mut c_void,
15350    pub memory_type_bits: u32,
15351}
15352impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA {
15353    fn default() -> Self {
15354        Self {
15355            s_type: StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA,
15356            p_next: ::std::ptr::null_mut(),
15357            memory_type_bits: u32::default(),
15358        }
15359    }
15360}
15361impl MemoryZirconHandlePropertiesFUCHSIA {
15362    pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15363        MemoryZirconHandlePropertiesFUCHSIABuilder {
15364            inner: Self::default(),
15365            marker: ::std::marker::PhantomData,
15366        }
15367    }
15368}
15369#[repr(transparent)]
15370pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15371    inner: MemoryZirconHandlePropertiesFUCHSIA,
15372    marker: ::std::marker::PhantomData<&'a ()>,
15373}
15374impl<'a> ::std::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15375    type Target = MemoryZirconHandlePropertiesFUCHSIA;
15376    fn deref(&self) -> &Self::Target {
15377        &self.inner
15378    }
15379}
15380impl<'a> ::std::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15381    fn deref_mut(&mut self) -> &mut Self::Target {
15382        &mut self.inner
15383    }
15384}
15385impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
15386    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
15387        self.inner.memory_type_bits = memory_type_bits;
15388        self
15389    }
15390    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15391    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15392    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15393    pub fn build(self) -> MemoryZirconHandlePropertiesFUCHSIA {
15394        self.inner
15395    }
15396}
15397#[repr(C)]
15398#[cfg_attr(feature = "debug", derive(Debug))]
15399#[derive(Copy, Clone)]
15400#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html>"]
15401pub struct MemoryGetZirconHandleInfoFUCHSIA {
15402    pub s_type: StructureType,
15403    pub p_next: *const c_void,
15404    pub memory: DeviceMemory,
15405    pub handle_type: ExternalMemoryHandleTypeFlags,
15406}
15407impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA {
15408    fn default() -> Self {
15409        Self {
15410            s_type: StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
15411            p_next: ::std::ptr::null(),
15412            memory: DeviceMemory::default(),
15413            handle_type: ExternalMemoryHandleTypeFlags::default(),
15414        }
15415    }
15416}
15417impl MemoryGetZirconHandleInfoFUCHSIA {
15418    pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15419        MemoryGetZirconHandleInfoFUCHSIABuilder {
15420            inner: Self::default(),
15421            marker: ::std::marker::PhantomData,
15422        }
15423    }
15424}
15425#[repr(transparent)]
15426pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15427    inner: MemoryGetZirconHandleInfoFUCHSIA,
15428    marker: ::std::marker::PhantomData<&'a ()>,
15429}
15430impl<'a> ::std::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15431    type Target = MemoryGetZirconHandleInfoFUCHSIA;
15432    fn deref(&self) -> &Self::Target {
15433        &self.inner
15434    }
15435}
15436impl<'a> ::std::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15437    fn deref_mut(&mut self) -> &mut Self::Target {
15438        &mut self.inner
15439    }
15440}
15441impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
15442    pub fn memory(mut self, memory: DeviceMemory) -> Self {
15443        self.inner.memory = memory;
15444        self
15445    }
15446    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15447        self.inner.handle_type = handle_type;
15448        self
15449    }
15450    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15451    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15452    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15453    pub fn build(self) -> MemoryGetZirconHandleInfoFUCHSIA {
15454        self.inner
15455    }
15456}
15457#[repr(C)]
15458#[cfg_attr(feature = "debug", derive(Debug))]
15459#[derive(Copy, Clone)]
15460#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html>"]
15461pub struct MemoryWin32HandlePropertiesKHR {
15462    pub s_type: StructureType,
15463    pub p_next: *mut c_void,
15464    pub memory_type_bits: u32,
15465}
15466impl ::std::default::Default for MemoryWin32HandlePropertiesKHR {
15467    fn default() -> Self {
15468        Self {
15469            s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
15470            p_next: ::std::ptr::null_mut(),
15471            memory_type_bits: u32::default(),
15472        }
15473    }
15474}
15475impl MemoryWin32HandlePropertiesKHR {
15476    pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
15477        MemoryWin32HandlePropertiesKHRBuilder {
15478            inner: Self::default(),
15479            marker: ::std::marker::PhantomData,
15480        }
15481    }
15482}
15483#[repr(transparent)]
15484pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> {
15485    inner: MemoryWin32HandlePropertiesKHR,
15486    marker: ::std::marker::PhantomData<&'a ()>,
15487}
15488impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> {
15489    type Target = MemoryWin32HandlePropertiesKHR;
15490    fn deref(&self) -> &Self::Target {
15491        &self.inner
15492    }
15493}
15494impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> {
15495    fn deref_mut(&mut self) -> &mut Self::Target {
15496        &mut self.inner
15497    }
15498}
15499impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
15500    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
15501        self.inner.memory_type_bits = memory_type_bits;
15502        self
15503    }
15504    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15505    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15506    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15507    pub fn build(self) -> MemoryWin32HandlePropertiesKHR {
15508        self.inner
15509    }
15510}
15511#[repr(C)]
15512#[cfg_attr(feature = "debug", derive(Debug))]
15513#[derive(Copy, Clone)]
15514#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html>"]
15515pub struct MemoryGetWin32HandleInfoKHR {
15516    pub s_type: StructureType,
15517    pub p_next: *const c_void,
15518    pub memory: DeviceMemory,
15519    pub handle_type: ExternalMemoryHandleTypeFlags,
15520}
15521impl ::std::default::Default for MemoryGetWin32HandleInfoKHR {
15522    fn default() -> Self {
15523        Self {
15524            s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR,
15525            p_next: ::std::ptr::null(),
15526            memory: DeviceMemory::default(),
15527            handle_type: ExternalMemoryHandleTypeFlags::default(),
15528        }
15529    }
15530}
15531impl MemoryGetWin32HandleInfoKHR {
15532    pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
15533        MemoryGetWin32HandleInfoKHRBuilder {
15534            inner: Self::default(),
15535            marker: ::std::marker::PhantomData,
15536        }
15537    }
15538}
15539#[repr(transparent)]
15540pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> {
15541    inner: MemoryGetWin32HandleInfoKHR,
15542    marker: ::std::marker::PhantomData<&'a ()>,
15543}
15544impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> {
15545    type Target = MemoryGetWin32HandleInfoKHR;
15546    fn deref(&self) -> &Self::Target {
15547        &self.inner
15548    }
15549}
15550impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> {
15551    fn deref_mut(&mut self) -> &mut Self::Target {
15552        &mut self.inner
15553    }
15554}
15555impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
15556    pub fn memory(mut self, memory: DeviceMemory) -> Self {
15557        self.inner.memory = memory;
15558        self
15559    }
15560    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15561        self.inner.handle_type = handle_type;
15562        self
15563    }
15564    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15565    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15566    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15567    pub fn build(self) -> MemoryGetWin32HandleInfoKHR {
15568        self.inner
15569    }
15570}
15571#[repr(C)]
15572#[cfg_attr(feature = "debug", derive(Debug))]
15573#[derive(Copy, Clone)]
15574#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryFdInfoKHR.html>"]
15575pub struct ImportMemoryFdInfoKHR {
15576    pub s_type: StructureType,
15577    pub p_next: *const c_void,
15578    pub handle_type: ExternalMemoryHandleTypeFlags,
15579    pub fd: c_int,
15580}
15581impl ::std::default::Default for ImportMemoryFdInfoKHR {
15582    fn default() -> Self {
15583        Self {
15584            s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR,
15585            p_next: ::std::ptr::null(),
15586            handle_type: ExternalMemoryHandleTypeFlags::default(),
15587            fd: c_int::default(),
15588        }
15589    }
15590}
15591impl ImportMemoryFdInfoKHR {
15592    pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> {
15593        ImportMemoryFdInfoKHRBuilder {
15594            inner: Self::default(),
15595            marker: ::std::marker::PhantomData,
15596        }
15597    }
15598}
15599#[repr(transparent)]
15600pub struct ImportMemoryFdInfoKHRBuilder<'a> {
15601    inner: ImportMemoryFdInfoKHR,
15602    marker: ::std::marker::PhantomData<&'a ()>,
15603}
15604unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {}
15605unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {}
15606impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> {
15607    type Target = ImportMemoryFdInfoKHR;
15608    fn deref(&self) -> &Self::Target {
15609        &self.inner
15610    }
15611}
15612impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> {
15613    fn deref_mut(&mut self) -> &mut Self::Target {
15614        &mut self.inner
15615    }
15616}
15617impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
15618    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15619        self.inner.handle_type = handle_type;
15620        self
15621    }
15622    pub fn fd(mut self, fd: c_int) -> Self {
15623        self.inner.fd = fd;
15624        self
15625    }
15626    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15627    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15628    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15629    pub fn build(self) -> ImportMemoryFdInfoKHR {
15630        self.inner
15631    }
15632}
15633#[repr(C)]
15634#[cfg_attr(feature = "debug", derive(Debug))]
15635#[derive(Copy, Clone)]
15636#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryFdPropertiesKHR.html>"]
15637pub struct MemoryFdPropertiesKHR {
15638    pub s_type: StructureType,
15639    pub p_next: *mut c_void,
15640    pub memory_type_bits: u32,
15641}
15642impl ::std::default::Default for MemoryFdPropertiesKHR {
15643    fn default() -> Self {
15644        Self {
15645            s_type: StructureType::MEMORY_FD_PROPERTIES_KHR,
15646            p_next: ::std::ptr::null_mut(),
15647            memory_type_bits: u32::default(),
15648        }
15649    }
15650}
15651impl MemoryFdPropertiesKHR {
15652    pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> {
15653        MemoryFdPropertiesKHRBuilder {
15654            inner: Self::default(),
15655            marker: ::std::marker::PhantomData,
15656        }
15657    }
15658}
15659#[repr(transparent)]
15660pub struct MemoryFdPropertiesKHRBuilder<'a> {
15661    inner: MemoryFdPropertiesKHR,
15662    marker: ::std::marker::PhantomData<&'a ()>,
15663}
15664impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> {
15665    type Target = MemoryFdPropertiesKHR;
15666    fn deref(&self) -> &Self::Target {
15667        &self.inner
15668    }
15669}
15670impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> {
15671    fn deref_mut(&mut self) -> &mut Self::Target {
15672        &mut self.inner
15673    }
15674}
15675impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
15676    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
15677        self.inner.memory_type_bits = memory_type_bits;
15678        self
15679    }
15680    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15681    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15682    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15683    pub fn build(self) -> MemoryFdPropertiesKHR {
15684        self.inner
15685    }
15686}
15687#[repr(C)]
15688#[cfg_attr(feature = "debug", derive(Debug))]
15689#[derive(Copy, Clone)]
15690#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetFdInfoKHR.html>"]
15691pub struct MemoryGetFdInfoKHR {
15692    pub s_type: StructureType,
15693    pub p_next: *const c_void,
15694    pub memory: DeviceMemory,
15695    pub handle_type: ExternalMemoryHandleTypeFlags,
15696}
15697impl ::std::default::Default for MemoryGetFdInfoKHR {
15698    fn default() -> Self {
15699        Self {
15700            s_type: StructureType::MEMORY_GET_FD_INFO_KHR,
15701            p_next: ::std::ptr::null(),
15702            memory: DeviceMemory::default(),
15703            handle_type: ExternalMemoryHandleTypeFlags::default(),
15704        }
15705    }
15706}
15707impl MemoryGetFdInfoKHR {
15708    pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> {
15709        MemoryGetFdInfoKHRBuilder {
15710            inner: Self::default(),
15711            marker: ::std::marker::PhantomData,
15712        }
15713    }
15714}
15715#[repr(transparent)]
15716pub struct MemoryGetFdInfoKHRBuilder<'a> {
15717    inner: MemoryGetFdInfoKHR,
15718    marker: ::std::marker::PhantomData<&'a ()>,
15719}
15720impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> {
15721    type Target = MemoryGetFdInfoKHR;
15722    fn deref(&self) -> &Self::Target {
15723        &self.inner
15724    }
15725}
15726impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> {
15727    fn deref_mut(&mut self) -> &mut Self::Target {
15728        &mut self.inner
15729    }
15730}
15731impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
15732    pub fn memory(mut self, memory: DeviceMemory) -> Self {
15733        self.inner.memory = memory;
15734        self
15735    }
15736    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
15737        self.inner.handle_type = handle_type;
15738        self
15739    }
15740    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15741    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15742    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15743    pub fn build(self) -> MemoryGetFdInfoKHR {
15744        self.inner
15745    }
15746}
15747#[repr(C)]
15748#[cfg_attr(feature = "debug", derive(Debug))]
15749#[derive(Copy, Clone)]
15750#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>"]
15751pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
15752    pub s_type: StructureType,
15753    pub p_next: *const c_void,
15754    pub acquire_count: u32,
15755    pub p_acquire_syncs: *const DeviceMemory,
15756    pub p_acquire_keys: *const u64,
15757    pub p_acquire_timeouts: *const u32,
15758    pub release_count: u32,
15759    pub p_release_syncs: *const DeviceMemory,
15760    pub p_release_keys: *const u64,
15761}
15762impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR {
15763    fn default() -> Self {
15764        Self {
15765            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
15766            p_next: ::std::ptr::null(),
15767            acquire_count: u32::default(),
15768            p_acquire_syncs: ::std::ptr::null(),
15769            p_acquire_keys: ::std::ptr::null(),
15770            p_acquire_timeouts: ::std::ptr::null(),
15771            release_count: u32::default(),
15772            p_release_syncs: ::std::ptr::null(),
15773            p_release_keys: ::std::ptr::null(),
15774        }
15775    }
15776}
15777impl Win32KeyedMutexAcquireReleaseInfoKHR {
15778    pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15779        Win32KeyedMutexAcquireReleaseInfoKHRBuilder {
15780            inner: Self::default(),
15781            marker: ::std::marker::PhantomData,
15782        }
15783    }
15784}
15785#[repr(transparent)]
15786pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15787    inner: Win32KeyedMutexAcquireReleaseInfoKHR,
15788    marker: ::std::marker::PhantomData<&'a ()>,
15789}
15790unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
15791unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {}
15792unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
15793unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR {}
15794impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15795    type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
15796    fn deref(&self) -> &Self::Target {
15797        &self.inner
15798    }
15799}
15800impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15801    fn deref_mut(&mut self) -> &mut Self::Target {
15802        &mut self.inner
15803    }
15804}
15805impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
15806    pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
15807        self.inner.acquire_count = acquire_syncs.len() as _;
15808        self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
15809        self
15810    }
15811    pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
15812        self.inner.acquire_count = acquire_keys.len() as _;
15813        self.inner.p_acquire_keys = acquire_keys.as_ptr();
15814        self
15815    }
15816    pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self {
15817        self.inner.acquire_count = acquire_timeouts.len() as _;
15818        self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr();
15819        self
15820    }
15821    pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
15822        self.inner.release_count = release_syncs.len() as _;
15823        self.inner.p_release_syncs = release_syncs.as_ptr();
15824        self
15825    }
15826    pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
15827        self.inner.release_count = release_keys.len() as _;
15828        self.inner.p_release_keys = release_keys.as_ptr();
15829        self
15830    }
15831    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15832    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15833    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15834    pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR {
15835        self.inner
15836    }
15837}
15838#[repr(C)]
15839#[cfg_attr(feature = "debug", derive(Debug))]
15840#[derive(Copy, Clone)]
15841#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>"]
15842pub struct PhysicalDeviceExternalSemaphoreInfo {
15843    pub s_type: StructureType,
15844    pub p_next: *const c_void,
15845    pub handle_type: ExternalSemaphoreHandleTypeFlags,
15846}
15847impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo {
15848    fn default() -> Self {
15849        Self {
15850            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
15851            p_next: ::std::ptr::null(),
15852            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
15853        }
15854    }
15855}
15856impl PhysicalDeviceExternalSemaphoreInfo {
15857    pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15858        PhysicalDeviceExternalSemaphoreInfoBuilder {
15859            inner: Self::default(),
15860            marker: ::std::marker::PhantomData,
15861        }
15862    }
15863}
15864#[repr(transparent)]
15865pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15866    inner: PhysicalDeviceExternalSemaphoreInfo,
15867    marker: ::std::marker::PhantomData<&'a ()>,
15868}
15869pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {}
15870impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15871    type Target = PhysicalDeviceExternalSemaphoreInfo;
15872    fn deref(&self) -> &Self::Target {
15873        &self.inner
15874    }
15875}
15876impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15877    fn deref_mut(&mut self) -> &mut Self::Target {
15878        &mut self.inner
15879    }
15880}
15881impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
15882    pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
15883        self.inner.handle_type = handle_type;
15884        self
15885    }
15886    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15887    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15888    #[doc = r" valid extension structs can be pushed into the chain."]
15889    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15890    #[doc = r" chain will look like `A -> D -> B -> C`."]
15891    pub fn push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>(
15892        mut self,
15893        next: &'a mut T,
15894    ) -> Self {
15895        unsafe {
15896            let next_ptr = <*const T>::cast(next);
15897            let last_next = ptr_chain_iter(next).last().unwrap();
15898            (*last_next).p_next = self.inner.p_next as _;
15899            self.inner.p_next = next_ptr;
15900        }
15901        self
15902    }
15903    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15904    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15905    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15906    pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo {
15907        self.inner
15908    }
15909}
15910#[repr(C)]
15911#[cfg_attr(feature = "debug", derive(Debug))]
15912#[derive(Copy, Clone)]
15913#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreProperties.html>"]
15914pub struct ExternalSemaphoreProperties {
15915    pub s_type: StructureType,
15916    pub p_next: *mut c_void,
15917    pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
15918    pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
15919    pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
15920}
15921impl ::std::default::Default for ExternalSemaphoreProperties {
15922    fn default() -> Self {
15923        Self {
15924            s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES,
15925            p_next: ::std::ptr::null_mut(),
15926            export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
15927            compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
15928            external_semaphore_features: ExternalSemaphoreFeatureFlags::default(),
15929        }
15930    }
15931}
15932impl ExternalSemaphoreProperties {
15933    pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> {
15934        ExternalSemaphorePropertiesBuilder {
15935            inner: Self::default(),
15936            marker: ::std::marker::PhantomData,
15937        }
15938    }
15939}
15940#[repr(transparent)]
15941pub struct ExternalSemaphorePropertiesBuilder<'a> {
15942    inner: ExternalSemaphoreProperties,
15943    marker: ::std::marker::PhantomData<&'a ()>,
15944}
15945impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> {
15946    type Target = ExternalSemaphoreProperties;
15947    fn deref(&self) -> &Self::Target {
15948        &self.inner
15949    }
15950}
15951impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> {
15952    fn deref_mut(&mut self) -> &mut Self::Target {
15953        &mut self.inner
15954    }
15955}
15956impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
15957    pub fn export_from_imported_handle_types(
15958        mut self,
15959        export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
15960    ) -> Self {
15961        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
15962        self
15963    }
15964    pub fn compatible_handle_types(
15965        mut self,
15966        compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
15967    ) -> Self {
15968        self.inner.compatible_handle_types = compatible_handle_types;
15969        self
15970    }
15971    pub fn external_semaphore_features(
15972        mut self,
15973        external_semaphore_features: ExternalSemaphoreFeatureFlags,
15974    ) -> Self {
15975        self.inner.external_semaphore_features = external_semaphore_features;
15976        self
15977    }
15978    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15979    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15980    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
15981    pub fn build(self) -> ExternalSemaphoreProperties {
15982        self.inner
15983    }
15984}
15985#[repr(C)]
15986#[cfg_attr(feature = "debug", derive(Debug))]
15987#[derive(Copy, Clone)]
15988#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreCreateInfo.html>"]
15989pub struct ExportSemaphoreCreateInfo {
15990    pub s_type: StructureType,
15991    pub p_next: *const c_void,
15992    pub handle_types: ExternalSemaphoreHandleTypeFlags,
15993}
15994impl ::std::default::Default for ExportSemaphoreCreateInfo {
15995    fn default() -> Self {
15996        Self {
15997            s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO,
15998            p_next: ::std::ptr::null(),
15999            handle_types: ExternalSemaphoreHandleTypeFlags::default(),
16000        }
16001    }
16002}
16003impl ExportSemaphoreCreateInfo {
16004    pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> {
16005        ExportSemaphoreCreateInfoBuilder {
16006            inner: Self::default(),
16007            marker: ::std::marker::PhantomData,
16008        }
16009    }
16010}
16011#[repr(transparent)]
16012pub struct ExportSemaphoreCreateInfoBuilder<'a> {
16013    inner: ExportSemaphoreCreateInfo,
16014    marker: ::std::marker::PhantomData<&'a ()>,
16015}
16016unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {}
16017unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {}
16018impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> {
16019    type Target = ExportSemaphoreCreateInfo;
16020    fn deref(&self) -> &Self::Target {
16021        &self.inner
16022    }
16023}
16024impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> {
16025    fn deref_mut(&mut self) -> &mut Self::Target {
16026        &mut self.inner
16027    }
16028}
16029impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
16030    pub fn handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self {
16031        self.inner.handle_types = handle_types;
16032        self
16033    }
16034    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16035    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16036    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16037    pub fn build(self) -> ExportSemaphoreCreateInfo {
16038        self.inner
16039    }
16040}
16041#[repr(C)]
16042#[cfg_attr(feature = "debug", derive(Debug))]
16043#[derive(Copy, Clone)]
16044#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>"]
16045pub struct ImportSemaphoreWin32HandleInfoKHR {
16046    pub s_type: StructureType,
16047    pub p_next: *const c_void,
16048    pub semaphore: Semaphore,
16049    pub flags: SemaphoreImportFlags,
16050    pub handle_type: ExternalSemaphoreHandleTypeFlags,
16051    pub handle: HANDLE,
16052    pub name: LPCWSTR,
16053}
16054impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR {
16055    fn default() -> Self {
16056        Self {
16057            s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
16058            p_next: ::std::ptr::null(),
16059            semaphore: Semaphore::default(),
16060            flags: SemaphoreImportFlags::default(),
16061            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16062            handle: unsafe { ::std::mem::zeroed() },
16063            name: unsafe { ::std::mem::zeroed() },
16064        }
16065    }
16066}
16067impl ImportSemaphoreWin32HandleInfoKHR {
16068    pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16069        ImportSemaphoreWin32HandleInfoKHRBuilder {
16070            inner: Self::default(),
16071            marker: ::std::marker::PhantomData,
16072        }
16073    }
16074}
16075#[repr(transparent)]
16076pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16077    inner: ImportSemaphoreWin32HandleInfoKHR,
16078    marker: ::std::marker::PhantomData<&'a ()>,
16079}
16080impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16081    type Target = ImportSemaphoreWin32HandleInfoKHR;
16082    fn deref(&self) -> &Self::Target {
16083        &self.inner
16084    }
16085}
16086impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16087    fn deref_mut(&mut self) -> &mut Self::Target {
16088        &mut self.inner
16089    }
16090}
16091impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16092    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16093        self.inner.semaphore = semaphore;
16094        self
16095    }
16096    pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
16097        self.inner.flags = flags;
16098        self
16099    }
16100    pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16101        self.inner.handle_type = handle_type;
16102        self
16103    }
16104    pub fn handle(mut self, handle: HANDLE) -> Self {
16105        self.inner.handle = handle;
16106        self
16107    }
16108    pub fn name(mut self, name: LPCWSTR) -> Self {
16109        self.inner.name = name;
16110        self
16111    }
16112    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16113    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16114    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16115    pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR {
16116        self.inner
16117    }
16118}
16119#[repr(C)]
16120#[cfg_attr(feature = "debug", derive(Debug))]
16121#[derive(Copy, Clone)]
16122#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>"]
16123pub struct ExportSemaphoreWin32HandleInfoKHR {
16124    pub s_type: StructureType,
16125    pub p_next: *const c_void,
16126    pub p_attributes: *const SECURITY_ATTRIBUTES,
16127    pub dw_access: DWORD,
16128    pub name: LPCWSTR,
16129}
16130impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR {
16131    fn default() -> Self {
16132        Self {
16133            s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
16134            p_next: ::std::ptr::null(),
16135            p_attributes: ::std::ptr::null(),
16136            dw_access: DWORD::default(),
16137            name: unsafe { ::std::mem::zeroed() },
16138        }
16139    }
16140}
16141impl ExportSemaphoreWin32HandleInfoKHR {
16142    pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16143        ExportSemaphoreWin32HandleInfoKHRBuilder {
16144            inner: Self::default(),
16145            marker: ::std::marker::PhantomData,
16146        }
16147    }
16148}
16149#[repr(transparent)]
16150pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16151    inner: ExportSemaphoreWin32HandleInfoKHR,
16152    marker: ::std::marker::PhantomData<&'a ()>,
16153}
16154unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {}
16155unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {}
16156impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16157    type Target = ExportSemaphoreWin32HandleInfoKHR;
16158    fn deref(&self) -> &Self::Target {
16159        &self.inner
16160    }
16161}
16162impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16163    fn deref_mut(&mut self) -> &mut Self::Target {
16164        &mut self.inner
16165    }
16166}
16167impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
16168    pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
16169        self.inner.p_attributes = attributes;
16170        self
16171    }
16172    pub fn dw_access(mut self, dw_access: DWORD) -> Self {
16173        self.inner.dw_access = dw_access;
16174        self
16175    }
16176    pub fn name(mut self, name: LPCWSTR) -> Self {
16177        self.inner.name = name;
16178        self
16179    }
16180    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16181    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16182    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16183    pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR {
16184        self.inner
16185    }
16186}
16187#[repr(C)]
16188#[cfg_attr(feature = "debug", derive(Debug))]
16189#[derive(Copy, Clone)]
16190#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html>"]
16191pub struct D3D12FenceSubmitInfoKHR {
16192    pub s_type: StructureType,
16193    pub p_next: *const c_void,
16194    pub wait_semaphore_values_count: u32,
16195    pub p_wait_semaphore_values: *const u64,
16196    pub signal_semaphore_values_count: u32,
16197    pub p_signal_semaphore_values: *const u64,
16198}
16199impl ::std::default::Default for D3D12FenceSubmitInfoKHR {
16200    fn default() -> Self {
16201        Self {
16202            s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR,
16203            p_next: ::std::ptr::null(),
16204            wait_semaphore_values_count: u32::default(),
16205            p_wait_semaphore_values: ::std::ptr::null(),
16206            signal_semaphore_values_count: u32::default(),
16207            p_signal_semaphore_values: ::std::ptr::null(),
16208        }
16209    }
16210}
16211impl D3D12FenceSubmitInfoKHR {
16212    pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> {
16213        D3D12FenceSubmitInfoKHRBuilder {
16214            inner: Self::default(),
16215            marker: ::std::marker::PhantomData,
16216        }
16217    }
16218}
16219#[repr(transparent)]
16220pub struct D3D12FenceSubmitInfoKHRBuilder<'a> {
16221    inner: D3D12FenceSubmitInfoKHR,
16222    marker: ::std::marker::PhantomData<&'a ()>,
16223}
16224unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {}
16225unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {}
16226impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> {
16227    type Target = D3D12FenceSubmitInfoKHR;
16228    fn deref(&self) -> &Self::Target {
16229        &self.inner
16230    }
16231}
16232impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> {
16233    fn deref_mut(&mut self) -> &mut Self::Target {
16234        &mut self.inner
16235    }
16236}
16237impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
16238    pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
16239        self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _;
16240        self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
16241        self
16242    }
16243    pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
16244        self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _;
16245        self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
16246        self
16247    }
16248    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16249    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16250    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16251    pub fn build(self) -> D3D12FenceSubmitInfoKHR {
16252        self.inner
16253    }
16254}
16255#[repr(C)]
16256#[cfg_attr(feature = "debug", derive(Debug))]
16257#[derive(Copy, Clone)]
16258#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>"]
16259pub struct SemaphoreGetWin32HandleInfoKHR {
16260    pub s_type: StructureType,
16261    pub p_next: *const c_void,
16262    pub semaphore: Semaphore,
16263    pub handle_type: ExternalSemaphoreHandleTypeFlags,
16264}
16265impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR {
16266    fn default() -> Self {
16267        Self {
16268            s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
16269            p_next: ::std::ptr::null(),
16270            semaphore: Semaphore::default(),
16271            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16272        }
16273    }
16274}
16275impl SemaphoreGetWin32HandleInfoKHR {
16276    pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16277        SemaphoreGetWin32HandleInfoKHRBuilder {
16278            inner: Self::default(),
16279            marker: ::std::marker::PhantomData,
16280        }
16281    }
16282}
16283#[repr(transparent)]
16284pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16285    inner: SemaphoreGetWin32HandleInfoKHR,
16286    marker: ::std::marker::PhantomData<&'a ()>,
16287}
16288impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16289    type Target = SemaphoreGetWin32HandleInfoKHR;
16290    fn deref(&self) -> &Self::Target {
16291        &self.inner
16292    }
16293}
16294impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16295    fn deref_mut(&mut self) -> &mut Self::Target {
16296        &mut self.inner
16297    }
16298}
16299impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
16300    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16301        self.inner.semaphore = semaphore;
16302        self
16303    }
16304    pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16305        self.inner.handle_type = handle_type;
16306        self
16307    }
16308    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16309    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16310    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16311    pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR {
16312        self.inner
16313    }
16314}
16315#[repr(C)]
16316#[cfg_attr(feature = "debug", derive(Debug))]
16317#[derive(Copy, Clone)]
16318#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreFdInfoKHR.html>"]
16319pub struct ImportSemaphoreFdInfoKHR {
16320    pub s_type: StructureType,
16321    pub p_next: *const c_void,
16322    pub semaphore: Semaphore,
16323    pub flags: SemaphoreImportFlags,
16324    pub handle_type: ExternalSemaphoreHandleTypeFlags,
16325    pub fd: c_int,
16326}
16327impl ::std::default::Default for ImportSemaphoreFdInfoKHR {
16328    fn default() -> Self {
16329        Self {
16330            s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR,
16331            p_next: ::std::ptr::null(),
16332            semaphore: Semaphore::default(),
16333            flags: SemaphoreImportFlags::default(),
16334            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16335            fd: c_int::default(),
16336        }
16337    }
16338}
16339impl ImportSemaphoreFdInfoKHR {
16340    pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> {
16341        ImportSemaphoreFdInfoKHRBuilder {
16342            inner: Self::default(),
16343            marker: ::std::marker::PhantomData,
16344        }
16345    }
16346}
16347#[repr(transparent)]
16348pub struct ImportSemaphoreFdInfoKHRBuilder<'a> {
16349    inner: ImportSemaphoreFdInfoKHR,
16350    marker: ::std::marker::PhantomData<&'a ()>,
16351}
16352impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> {
16353    type Target = ImportSemaphoreFdInfoKHR;
16354    fn deref(&self) -> &Self::Target {
16355        &self.inner
16356    }
16357}
16358impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> {
16359    fn deref_mut(&mut self) -> &mut Self::Target {
16360        &mut self.inner
16361    }
16362}
16363impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
16364    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16365        self.inner.semaphore = semaphore;
16366        self
16367    }
16368    pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
16369        self.inner.flags = flags;
16370        self
16371    }
16372    pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16373        self.inner.handle_type = handle_type;
16374        self
16375    }
16376    pub fn fd(mut self, fd: c_int) -> Self {
16377        self.inner.fd = fd;
16378        self
16379    }
16380    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16381    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16382    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16383    pub fn build(self) -> ImportSemaphoreFdInfoKHR {
16384        self.inner
16385    }
16386}
16387#[repr(C)]
16388#[cfg_attr(feature = "debug", derive(Debug))]
16389#[derive(Copy, Clone)]
16390#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetFdInfoKHR.html>"]
16391pub struct SemaphoreGetFdInfoKHR {
16392    pub s_type: StructureType,
16393    pub p_next: *const c_void,
16394    pub semaphore: Semaphore,
16395    pub handle_type: ExternalSemaphoreHandleTypeFlags,
16396}
16397impl ::std::default::Default for SemaphoreGetFdInfoKHR {
16398    fn default() -> Self {
16399        Self {
16400            s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR,
16401            p_next: ::std::ptr::null(),
16402            semaphore: Semaphore::default(),
16403            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16404        }
16405    }
16406}
16407impl SemaphoreGetFdInfoKHR {
16408    pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> {
16409        SemaphoreGetFdInfoKHRBuilder {
16410            inner: Self::default(),
16411            marker: ::std::marker::PhantomData,
16412        }
16413    }
16414}
16415#[repr(transparent)]
16416pub struct SemaphoreGetFdInfoKHRBuilder<'a> {
16417    inner: SemaphoreGetFdInfoKHR,
16418    marker: ::std::marker::PhantomData<&'a ()>,
16419}
16420impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> {
16421    type Target = SemaphoreGetFdInfoKHR;
16422    fn deref(&self) -> &Self::Target {
16423        &self.inner
16424    }
16425}
16426impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> {
16427    fn deref_mut(&mut self) -> &mut Self::Target {
16428        &mut self.inner
16429    }
16430}
16431impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
16432    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16433        self.inner.semaphore = semaphore;
16434        self
16435    }
16436    pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16437        self.inner.handle_type = handle_type;
16438        self
16439    }
16440    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16441    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16442    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16443    pub fn build(self) -> SemaphoreGetFdInfoKHR {
16444        self.inner
16445    }
16446}
16447#[repr(C)]
16448#[cfg_attr(feature = "debug", derive(Debug))]
16449#[derive(Copy, Clone)]
16450#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html>"]
16451pub struct ImportSemaphoreZirconHandleInfoFUCHSIA {
16452    pub s_type: StructureType,
16453    pub p_next: *const c_void,
16454    pub semaphore: Semaphore,
16455    pub flags: SemaphoreImportFlags,
16456    pub handle_type: ExternalSemaphoreHandleTypeFlags,
16457    pub zircon_handle: zx_handle_t,
16458}
16459impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA {
16460    fn default() -> Self {
16461        Self {
16462            s_type: StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA,
16463            p_next: ::std::ptr::null(),
16464            semaphore: Semaphore::default(),
16465            flags: SemaphoreImportFlags::default(),
16466            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16467            zircon_handle: zx_handle_t::default(),
16468        }
16469    }
16470}
16471impl ImportSemaphoreZirconHandleInfoFUCHSIA {
16472    pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16473        ImportSemaphoreZirconHandleInfoFUCHSIABuilder {
16474            inner: Self::default(),
16475            marker: ::std::marker::PhantomData,
16476        }
16477    }
16478}
16479#[repr(transparent)]
16480pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16481    inner: ImportSemaphoreZirconHandleInfoFUCHSIA,
16482    marker: ::std::marker::PhantomData<&'a ()>,
16483}
16484impl<'a> ::std::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16485    type Target = ImportSemaphoreZirconHandleInfoFUCHSIA;
16486    fn deref(&self) -> &Self::Target {
16487        &self.inner
16488    }
16489}
16490impl<'a> ::std::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16491    fn deref_mut(&mut self) -> &mut Self::Target {
16492        &mut self.inner
16493    }
16494}
16495impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
16496    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16497        self.inner.semaphore = semaphore;
16498        self
16499    }
16500    pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
16501        self.inner.flags = flags;
16502        self
16503    }
16504    pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16505        self.inner.handle_type = handle_type;
16506        self
16507    }
16508    pub fn zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self {
16509        self.inner.zircon_handle = zircon_handle;
16510        self
16511    }
16512    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16513    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16514    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16515    pub fn build(self) -> ImportSemaphoreZirconHandleInfoFUCHSIA {
16516        self.inner
16517    }
16518}
16519#[repr(C)]
16520#[cfg_attr(feature = "debug", derive(Debug))]
16521#[derive(Copy, Clone)]
16522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html>"]
16523pub struct SemaphoreGetZirconHandleInfoFUCHSIA {
16524    pub s_type: StructureType,
16525    pub p_next: *const c_void,
16526    pub semaphore: Semaphore,
16527    pub handle_type: ExternalSemaphoreHandleTypeFlags,
16528}
16529impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA {
16530    fn default() -> Self {
16531        Self {
16532            s_type: StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
16533            p_next: ::std::ptr::null(),
16534            semaphore: Semaphore::default(),
16535            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
16536        }
16537    }
16538}
16539impl SemaphoreGetZirconHandleInfoFUCHSIA {
16540    pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16541        SemaphoreGetZirconHandleInfoFUCHSIABuilder {
16542            inner: Self::default(),
16543            marker: ::std::marker::PhantomData,
16544        }
16545    }
16546}
16547#[repr(transparent)]
16548pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16549    inner: SemaphoreGetZirconHandleInfoFUCHSIA,
16550    marker: ::std::marker::PhantomData<&'a ()>,
16551}
16552impl<'a> ::std::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16553    type Target = SemaphoreGetZirconHandleInfoFUCHSIA;
16554    fn deref(&self) -> &Self::Target {
16555        &self.inner
16556    }
16557}
16558impl<'a> ::std::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16559    fn deref_mut(&mut self) -> &mut Self::Target {
16560        &mut self.inner
16561    }
16562}
16563impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
16564    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
16565        self.inner.semaphore = semaphore;
16566        self
16567    }
16568    pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
16569        self.inner.handle_type = handle_type;
16570        self
16571    }
16572    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16573    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16574    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16575    pub fn build(self) -> SemaphoreGetZirconHandleInfoFUCHSIA {
16576        self.inner
16577    }
16578}
16579#[repr(C)]
16580#[cfg_attr(feature = "debug", derive(Debug))]
16581#[derive(Copy, Clone)]
16582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html>"]
16583pub struct PhysicalDeviceExternalFenceInfo {
16584    pub s_type: StructureType,
16585    pub p_next: *const c_void,
16586    pub handle_type: ExternalFenceHandleTypeFlags,
16587}
16588impl ::std::default::Default for PhysicalDeviceExternalFenceInfo {
16589    fn default() -> Self {
16590        Self {
16591            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
16592            p_next: ::std::ptr::null(),
16593            handle_type: ExternalFenceHandleTypeFlags::default(),
16594        }
16595    }
16596}
16597impl PhysicalDeviceExternalFenceInfo {
16598    pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
16599        PhysicalDeviceExternalFenceInfoBuilder {
16600            inner: Self::default(),
16601            marker: ::std::marker::PhantomData,
16602        }
16603    }
16604}
16605#[repr(transparent)]
16606pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> {
16607    inner: PhysicalDeviceExternalFenceInfo,
16608    marker: ::std::marker::PhantomData<&'a ()>,
16609}
16610impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> {
16611    type Target = PhysicalDeviceExternalFenceInfo;
16612    fn deref(&self) -> &Self::Target {
16613        &self.inner
16614    }
16615}
16616impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> {
16617    fn deref_mut(&mut self) -> &mut Self::Target {
16618        &mut self.inner
16619    }
16620}
16621impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
16622    pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
16623        self.inner.handle_type = handle_type;
16624        self
16625    }
16626    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16627    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16628    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16629    pub fn build(self) -> PhysicalDeviceExternalFenceInfo {
16630        self.inner
16631    }
16632}
16633#[repr(C)]
16634#[cfg_attr(feature = "debug", derive(Debug))]
16635#[derive(Copy, Clone)]
16636#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceProperties.html>"]
16637pub struct ExternalFenceProperties {
16638    pub s_type: StructureType,
16639    pub p_next: *mut c_void,
16640    pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
16641    pub compatible_handle_types: ExternalFenceHandleTypeFlags,
16642    pub external_fence_features: ExternalFenceFeatureFlags,
16643}
16644impl ::std::default::Default for ExternalFenceProperties {
16645    fn default() -> Self {
16646        Self {
16647            s_type: StructureType::EXTERNAL_FENCE_PROPERTIES,
16648            p_next: ::std::ptr::null_mut(),
16649            export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(),
16650            compatible_handle_types: ExternalFenceHandleTypeFlags::default(),
16651            external_fence_features: ExternalFenceFeatureFlags::default(),
16652        }
16653    }
16654}
16655impl ExternalFenceProperties {
16656    pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> {
16657        ExternalFencePropertiesBuilder {
16658            inner: Self::default(),
16659            marker: ::std::marker::PhantomData,
16660        }
16661    }
16662}
16663#[repr(transparent)]
16664pub struct ExternalFencePropertiesBuilder<'a> {
16665    inner: ExternalFenceProperties,
16666    marker: ::std::marker::PhantomData<&'a ()>,
16667}
16668impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> {
16669    type Target = ExternalFenceProperties;
16670    fn deref(&self) -> &Self::Target {
16671        &self.inner
16672    }
16673}
16674impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> {
16675    fn deref_mut(&mut self) -> &mut Self::Target {
16676        &mut self.inner
16677    }
16678}
16679impl<'a> ExternalFencePropertiesBuilder<'a> {
16680    pub fn export_from_imported_handle_types(
16681        mut self,
16682        export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
16683    ) -> Self {
16684        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
16685        self
16686    }
16687    pub fn compatible_handle_types(
16688        mut self,
16689        compatible_handle_types: ExternalFenceHandleTypeFlags,
16690    ) -> Self {
16691        self.inner.compatible_handle_types = compatible_handle_types;
16692        self
16693    }
16694    pub fn external_fence_features(
16695        mut self,
16696        external_fence_features: ExternalFenceFeatureFlags,
16697    ) -> Self {
16698        self.inner.external_fence_features = external_fence_features;
16699        self
16700    }
16701    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16702    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16703    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16704    pub fn build(self) -> ExternalFenceProperties {
16705        self.inner
16706    }
16707}
16708#[repr(C)]
16709#[cfg_attr(feature = "debug", derive(Debug))]
16710#[derive(Copy, Clone)]
16711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceCreateInfo.html>"]
16712pub struct ExportFenceCreateInfo {
16713    pub s_type: StructureType,
16714    pub p_next: *const c_void,
16715    pub handle_types: ExternalFenceHandleTypeFlags,
16716}
16717impl ::std::default::Default for ExportFenceCreateInfo {
16718    fn default() -> Self {
16719        Self {
16720            s_type: StructureType::EXPORT_FENCE_CREATE_INFO,
16721            p_next: ::std::ptr::null(),
16722            handle_types: ExternalFenceHandleTypeFlags::default(),
16723        }
16724    }
16725}
16726impl ExportFenceCreateInfo {
16727    pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> {
16728        ExportFenceCreateInfoBuilder {
16729            inner: Self::default(),
16730            marker: ::std::marker::PhantomData,
16731        }
16732    }
16733}
16734#[repr(transparent)]
16735pub struct ExportFenceCreateInfoBuilder<'a> {
16736    inner: ExportFenceCreateInfo,
16737    marker: ::std::marker::PhantomData<&'a ()>,
16738}
16739unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {}
16740unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {}
16741impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> {
16742    type Target = ExportFenceCreateInfo;
16743    fn deref(&self) -> &Self::Target {
16744        &self.inner
16745    }
16746}
16747impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> {
16748    fn deref_mut(&mut self) -> &mut Self::Target {
16749        &mut self.inner
16750    }
16751}
16752impl<'a> ExportFenceCreateInfoBuilder<'a> {
16753    pub fn handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self {
16754        self.inner.handle_types = handle_types;
16755        self
16756    }
16757    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16758    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16759    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16760    pub fn build(self) -> ExportFenceCreateInfo {
16761        self.inner
16762    }
16763}
16764#[repr(C)]
16765#[cfg_attr(feature = "debug", derive(Debug))]
16766#[derive(Copy, Clone)]
16767#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceWin32HandleInfoKHR.html>"]
16768pub struct ImportFenceWin32HandleInfoKHR {
16769    pub s_type: StructureType,
16770    pub p_next: *const c_void,
16771    pub fence: Fence,
16772    pub flags: FenceImportFlags,
16773    pub handle_type: ExternalFenceHandleTypeFlags,
16774    pub handle: HANDLE,
16775    pub name: LPCWSTR,
16776}
16777impl ::std::default::Default for ImportFenceWin32HandleInfoKHR {
16778    fn default() -> Self {
16779        Self {
16780            s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
16781            p_next: ::std::ptr::null(),
16782            fence: Fence::default(),
16783            flags: FenceImportFlags::default(),
16784            handle_type: ExternalFenceHandleTypeFlags::default(),
16785            handle: unsafe { ::std::mem::zeroed() },
16786            name: unsafe { ::std::mem::zeroed() },
16787        }
16788    }
16789}
16790impl ImportFenceWin32HandleInfoKHR {
16791    pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
16792        ImportFenceWin32HandleInfoKHRBuilder {
16793            inner: Self::default(),
16794            marker: ::std::marker::PhantomData,
16795        }
16796    }
16797}
16798#[repr(transparent)]
16799pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> {
16800    inner: ImportFenceWin32HandleInfoKHR,
16801    marker: ::std::marker::PhantomData<&'a ()>,
16802}
16803impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> {
16804    type Target = ImportFenceWin32HandleInfoKHR;
16805    fn deref(&self) -> &Self::Target {
16806        &self.inner
16807    }
16808}
16809impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> {
16810    fn deref_mut(&mut self) -> &mut Self::Target {
16811        &mut self.inner
16812    }
16813}
16814impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
16815    pub fn fence(mut self, fence: Fence) -> Self {
16816        self.inner.fence = fence;
16817        self
16818    }
16819    pub fn flags(mut self, flags: FenceImportFlags) -> Self {
16820        self.inner.flags = flags;
16821        self
16822    }
16823    pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
16824        self.inner.handle_type = handle_type;
16825        self
16826    }
16827    pub fn handle(mut self, handle: HANDLE) -> Self {
16828        self.inner.handle = handle;
16829        self
16830    }
16831    pub fn name(mut self, name: LPCWSTR) -> Self {
16832        self.inner.name = name;
16833        self
16834    }
16835    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16836    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16837    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16838    pub fn build(self) -> ImportFenceWin32HandleInfoKHR {
16839        self.inner
16840    }
16841}
16842#[repr(C)]
16843#[cfg_attr(feature = "debug", derive(Debug))]
16844#[derive(Copy, Clone)]
16845#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html>"]
16846pub struct ExportFenceWin32HandleInfoKHR {
16847    pub s_type: StructureType,
16848    pub p_next: *const c_void,
16849    pub p_attributes: *const SECURITY_ATTRIBUTES,
16850    pub dw_access: DWORD,
16851    pub name: LPCWSTR,
16852}
16853impl ::std::default::Default for ExportFenceWin32HandleInfoKHR {
16854    fn default() -> Self {
16855        Self {
16856            s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
16857            p_next: ::std::ptr::null(),
16858            p_attributes: ::std::ptr::null(),
16859            dw_access: DWORD::default(),
16860            name: unsafe { ::std::mem::zeroed() },
16861        }
16862    }
16863}
16864impl ExportFenceWin32HandleInfoKHR {
16865    pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
16866        ExportFenceWin32HandleInfoKHRBuilder {
16867            inner: Self::default(),
16868            marker: ::std::marker::PhantomData,
16869        }
16870    }
16871}
16872#[repr(transparent)]
16873pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> {
16874    inner: ExportFenceWin32HandleInfoKHR,
16875    marker: ::std::marker::PhantomData<&'a ()>,
16876}
16877unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {}
16878unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {}
16879impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> {
16880    type Target = ExportFenceWin32HandleInfoKHR;
16881    fn deref(&self) -> &Self::Target {
16882        &self.inner
16883    }
16884}
16885impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> {
16886    fn deref_mut(&mut self) -> &mut Self::Target {
16887        &mut self.inner
16888    }
16889}
16890impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
16891    pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
16892        self.inner.p_attributes = attributes;
16893        self
16894    }
16895    pub fn dw_access(mut self, dw_access: DWORD) -> Self {
16896        self.inner.dw_access = dw_access;
16897        self
16898    }
16899    pub fn name(mut self, name: LPCWSTR) -> Self {
16900        self.inner.name = name;
16901        self
16902    }
16903    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16904    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16905    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16906    pub fn build(self) -> ExportFenceWin32HandleInfoKHR {
16907        self.inner
16908    }
16909}
16910#[repr(C)]
16911#[cfg_attr(feature = "debug", derive(Debug))]
16912#[derive(Copy, Clone)]
16913#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html>"]
16914pub struct FenceGetWin32HandleInfoKHR {
16915    pub s_type: StructureType,
16916    pub p_next: *const c_void,
16917    pub fence: Fence,
16918    pub handle_type: ExternalFenceHandleTypeFlags,
16919}
16920impl ::std::default::Default for FenceGetWin32HandleInfoKHR {
16921    fn default() -> Self {
16922        Self {
16923            s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR,
16924            p_next: ::std::ptr::null(),
16925            fence: Fence::default(),
16926            handle_type: ExternalFenceHandleTypeFlags::default(),
16927        }
16928    }
16929}
16930impl FenceGetWin32HandleInfoKHR {
16931    pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> {
16932        FenceGetWin32HandleInfoKHRBuilder {
16933            inner: Self::default(),
16934            marker: ::std::marker::PhantomData,
16935        }
16936    }
16937}
16938#[repr(transparent)]
16939pub struct FenceGetWin32HandleInfoKHRBuilder<'a> {
16940    inner: FenceGetWin32HandleInfoKHR,
16941    marker: ::std::marker::PhantomData<&'a ()>,
16942}
16943impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> {
16944    type Target = FenceGetWin32HandleInfoKHR;
16945    fn deref(&self) -> &Self::Target {
16946        &self.inner
16947    }
16948}
16949impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> {
16950    fn deref_mut(&mut self) -> &mut Self::Target {
16951        &mut self.inner
16952    }
16953}
16954impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
16955    pub fn fence(mut self, fence: Fence) -> Self {
16956        self.inner.fence = fence;
16957        self
16958    }
16959    pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
16960        self.inner.handle_type = handle_type;
16961        self
16962    }
16963    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16964    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16965    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
16966    pub fn build(self) -> FenceGetWin32HandleInfoKHR {
16967        self.inner
16968    }
16969}
16970#[repr(C)]
16971#[cfg_attr(feature = "debug", derive(Debug))]
16972#[derive(Copy, Clone)]
16973#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceFdInfoKHR.html>"]
16974pub struct ImportFenceFdInfoKHR {
16975    pub s_type: StructureType,
16976    pub p_next: *const c_void,
16977    pub fence: Fence,
16978    pub flags: FenceImportFlags,
16979    pub handle_type: ExternalFenceHandleTypeFlags,
16980    pub fd: c_int,
16981}
16982impl ::std::default::Default for ImportFenceFdInfoKHR {
16983    fn default() -> Self {
16984        Self {
16985            s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR,
16986            p_next: ::std::ptr::null(),
16987            fence: Fence::default(),
16988            flags: FenceImportFlags::default(),
16989            handle_type: ExternalFenceHandleTypeFlags::default(),
16990            fd: c_int::default(),
16991        }
16992    }
16993}
16994impl ImportFenceFdInfoKHR {
16995    pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> {
16996        ImportFenceFdInfoKHRBuilder {
16997            inner: Self::default(),
16998            marker: ::std::marker::PhantomData,
16999        }
17000    }
17001}
17002#[repr(transparent)]
17003pub struct ImportFenceFdInfoKHRBuilder<'a> {
17004    inner: ImportFenceFdInfoKHR,
17005    marker: ::std::marker::PhantomData<&'a ()>,
17006}
17007impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> {
17008    type Target = ImportFenceFdInfoKHR;
17009    fn deref(&self) -> &Self::Target {
17010        &self.inner
17011    }
17012}
17013impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> {
17014    fn deref_mut(&mut self) -> &mut Self::Target {
17015        &mut self.inner
17016    }
17017}
17018impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
17019    pub fn fence(mut self, fence: Fence) -> Self {
17020        self.inner.fence = fence;
17021        self
17022    }
17023    pub fn flags(mut self, flags: FenceImportFlags) -> Self {
17024        self.inner.flags = flags;
17025        self
17026    }
17027    pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
17028        self.inner.handle_type = handle_type;
17029        self
17030    }
17031    pub fn fd(mut self, fd: c_int) -> Self {
17032        self.inner.fd = fd;
17033        self
17034    }
17035    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17036    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17037    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17038    pub fn build(self) -> ImportFenceFdInfoKHR {
17039        self.inner
17040    }
17041}
17042#[repr(C)]
17043#[cfg_attr(feature = "debug", derive(Debug))]
17044#[derive(Copy, Clone)]
17045#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetFdInfoKHR.html>"]
17046pub struct FenceGetFdInfoKHR {
17047    pub s_type: StructureType,
17048    pub p_next: *const c_void,
17049    pub fence: Fence,
17050    pub handle_type: ExternalFenceHandleTypeFlags,
17051}
17052impl ::std::default::Default for FenceGetFdInfoKHR {
17053    fn default() -> Self {
17054        Self {
17055            s_type: StructureType::FENCE_GET_FD_INFO_KHR,
17056            p_next: ::std::ptr::null(),
17057            fence: Fence::default(),
17058            handle_type: ExternalFenceHandleTypeFlags::default(),
17059        }
17060    }
17061}
17062impl FenceGetFdInfoKHR {
17063    pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> {
17064        FenceGetFdInfoKHRBuilder {
17065            inner: Self::default(),
17066            marker: ::std::marker::PhantomData,
17067        }
17068    }
17069}
17070#[repr(transparent)]
17071pub struct FenceGetFdInfoKHRBuilder<'a> {
17072    inner: FenceGetFdInfoKHR,
17073    marker: ::std::marker::PhantomData<&'a ()>,
17074}
17075impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> {
17076    type Target = FenceGetFdInfoKHR;
17077    fn deref(&self) -> &Self::Target {
17078        &self.inner
17079    }
17080}
17081impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> {
17082    fn deref_mut(&mut self) -> &mut Self::Target {
17083        &mut self.inner
17084    }
17085}
17086impl<'a> FenceGetFdInfoKHRBuilder<'a> {
17087    pub fn fence(mut self, fence: Fence) -> Self {
17088        self.inner.fence = fence;
17089        self
17090    }
17091    pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
17092        self.inner.handle_type = handle_type;
17093        self
17094    }
17095    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17096    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17097    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17098    pub fn build(self) -> FenceGetFdInfoKHR {
17099        self.inner
17100    }
17101}
17102#[repr(C)]
17103#[cfg_attr(feature = "debug", derive(Debug))]
17104#[derive(Copy, Clone)]
17105#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html>"]
17106pub struct PhysicalDeviceMultiviewFeatures {
17107    pub s_type: StructureType,
17108    pub p_next: *mut c_void,
17109    pub multiview: Bool32,
17110    pub multiview_geometry_shader: Bool32,
17111    pub multiview_tessellation_shader: Bool32,
17112}
17113impl ::std::default::Default for PhysicalDeviceMultiviewFeatures {
17114    fn default() -> Self {
17115        Self {
17116            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
17117            p_next: ::std::ptr::null_mut(),
17118            multiview: Bool32::default(),
17119            multiview_geometry_shader: Bool32::default(),
17120            multiview_tessellation_shader: Bool32::default(),
17121        }
17122    }
17123}
17124impl PhysicalDeviceMultiviewFeatures {
17125    pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17126        PhysicalDeviceMultiviewFeaturesBuilder {
17127            inner: Self::default(),
17128            marker: ::std::marker::PhantomData,
17129        }
17130    }
17131}
17132#[repr(transparent)]
17133pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17134    inner: PhysicalDeviceMultiviewFeatures,
17135    marker: ::std::marker::PhantomData<&'a ()>,
17136}
17137unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
17138unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {}
17139unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
17140unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {}
17141impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17142    type Target = PhysicalDeviceMultiviewFeatures;
17143    fn deref(&self) -> &Self::Target {
17144        &self.inner
17145    }
17146}
17147impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17148    fn deref_mut(&mut self) -> &mut Self::Target {
17149        &mut self.inner
17150    }
17151}
17152impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
17153    pub fn multiview(mut self, multiview: bool) -> Self {
17154        self.inner.multiview = multiview.into();
17155        self
17156    }
17157    pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
17158        self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
17159        self
17160    }
17161    pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
17162        self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
17163        self
17164    }
17165    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17166    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17167    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17168    pub fn build(self) -> PhysicalDeviceMultiviewFeatures {
17169        self.inner
17170    }
17171}
17172#[repr(C)]
17173#[cfg_attr(feature = "debug", derive(Debug))]
17174#[derive(Copy, Clone)]
17175#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html>"]
17176pub struct PhysicalDeviceMultiviewProperties {
17177    pub s_type: StructureType,
17178    pub p_next: *mut c_void,
17179    pub max_multiview_view_count: u32,
17180    pub max_multiview_instance_index: u32,
17181}
17182impl ::std::default::Default for PhysicalDeviceMultiviewProperties {
17183    fn default() -> Self {
17184        Self {
17185            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
17186            p_next: ::std::ptr::null_mut(),
17187            max_multiview_view_count: u32::default(),
17188            max_multiview_instance_index: u32::default(),
17189        }
17190    }
17191}
17192impl PhysicalDeviceMultiviewProperties {
17193    pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17194        PhysicalDeviceMultiviewPropertiesBuilder {
17195            inner: Self::default(),
17196            marker: ::std::marker::PhantomData,
17197        }
17198    }
17199}
17200#[repr(transparent)]
17201pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17202    inner: PhysicalDeviceMultiviewProperties,
17203    marker: ::std::marker::PhantomData<&'a ()>,
17204}
17205unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {}
17206unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {}
17207impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17208    type Target = PhysicalDeviceMultiviewProperties;
17209    fn deref(&self) -> &Self::Target {
17210        &self.inner
17211    }
17212}
17213impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17214    fn deref_mut(&mut self) -> &mut Self::Target {
17215        &mut self.inner
17216    }
17217}
17218impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
17219    pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
17220        self.inner.max_multiview_view_count = max_multiview_view_count;
17221        self
17222    }
17223    pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
17224        self.inner.max_multiview_instance_index = max_multiview_instance_index;
17225        self
17226    }
17227    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17228    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17229    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17230    pub fn build(self) -> PhysicalDeviceMultiviewProperties {
17231        self.inner
17232    }
17233}
17234#[repr(C)]
17235#[cfg_attr(feature = "debug", derive(Debug))]
17236#[derive(Copy, Clone)]
17237#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassMultiviewCreateInfo.html>"]
17238pub struct RenderPassMultiviewCreateInfo {
17239    pub s_type: StructureType,
17240    pub p_next: *const c_void,
17241    pub subpass_count: u32,
17242    pub p_view_masks: *const u32,
17243    pub dependency_count: u32,
17244    pub p_view_offsets: *const i32,
17245    pub correlation_mask_count: u32,
17246    pub p_correlation_masks: *const u32,
17247}
17248impl ::std::default::Default for RenderPassMultiviewCreateInfo {
17249    fn default() -> Self {
17250        Self {
17251            s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO,
17252            p_next: ::std::ptr::null(),
17253            subpass_count: u32::default(),
17254            p_view_masks: ::std::ptr::null(),
17255            dependency_count: u32::default(),
17256            p_view_offsets: ::std::ptr::null(),
17257            correlation_mask_count: u32::default(),
17258            p_correlation_masks: ::std::ptr::null(),
17259        }
17260    }
17261}
17262impl RenderPassMultiviewCreateInfo {
17263    pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> {
17264        RenderPassMultiviewCreateInfoBuilder {
17265            inner: Self::default(),
17266            marker: ::std::marker::PhantomData,
17267        }
17268    }
17269}
17270#[repr(transparent)]
17271pub struct RenderPassMultiviewCreateInfoBuilder<'a> {
17272    inner: RenderPassMultiviewCreateInfo,
17273    marker: ::std::marker::PhantomData<&'a ()>,
17274}
17275unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {}
17276unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {}
17277impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> {
17278    type Target = RenderPassMultiviewCreateInfo;
17279    fn deref(&self) -> &Self::Target {
17280        &self.inner
17281    }
17282}
17283impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> {
17284    fn deref_mut(&mut self) -> &mut Self::Target {
17285        &mut self.inner
17286    }
17287}
17288impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
17289    pub fn view_masks(mut self, view_masks: &'a [u32]) -> Self {
17290        self.inner.subpass_count = view_masks.len() as _;
17291        self.inner.p_view_masks = view_masks.as_ptr();
17292        self
17293    }
17294    pub fn view_offsets(mut self, view_offsets: &'a [i32]) -> Self {
17295        self.inner.dependency_count = view_offsets.len() as _;
17296        self.inner.p_view_offsets = view_offsets.as_ptr();
17297        self
17298    }
17299    pub fn correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self {
17300        self.inner.correlation_mask_count = correlation_masks.len() as _;
17301        self.inner.p_correlation_masks = correlation_masks.as_ptr();
17302        self
17303    }
17304    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17305    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17306    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17307    pub fn build(self) -> RenderPassMultiviewCreateInfo {
17308        self.inner
17309    }
17310}
17311#[repr(C)]
17312#[cfg_attr(feature = "debug", derive(Debug))]
17313#[derive(Copy, Clone)]
17314#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2EXT.html>"]
17315pub struct SurfaceCapabilities2EXT {
17316    pub s_type: StructureType,
17317    pub p_next: *mut c_void,
17318    pub min_image_count: u32,
17319    pub max_image_count: u32,
17320    pub current_extent: Extent2D,
17321    pub min_image_extent: Extent2D,
17322    pub max_image_extent: Extent2D,
17323    pub max_image_array_layers: u32,
17324    pub supported_transforms: SurfaceTransformFlagsKHR,
17325    pub current_transform: SurfaceTransformFlagsKHR,
17326    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
17327    pub supported_usage_flags: ImageUsageFlags,
17328    pub supported_surface_counters: SurfaceCounterFlagsEXT,
17329}
17330impl ::std::default::Default for SurfaceCapabilities2EXT {
17331    fn default() -> Self {
17332        Self {
17333            s_type: StructureType::SURFACE_CAPABILITIES_2_EXT,
17334            p_next: ::std::ptr::null_mut(),
17335            min_image_count: u32::default(),
17336            max_image_count: u32::default(),
17337            current_extent: Extent2D::default(),
17338            min_image_extent: Extent2D::default(),
17339            max_image_extent: Extent2D::default(),
17340            max_image_array_layers: u32::default(),
17341            supported_transforms: SurfaceTransformFlagsKHR::default(),
17342            current_transform: SurfaceTransformFlagsKHR::default(),
17343            supported_composite_alpha: CompositeAlphaFlagsKHR::default(),
17344            supported_usage_flags: ImageUsageFlags::default(),
17345            supported_surface_counters: SurfaceCounterFlagsEXT::default(),
17346        }
17347    }
17348}
17349impl SurfaceCapabilities2EXT {
17350    pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> {
17351        SurfaceCapabilities2EXTBuilder {
17352            inner: Self::default(),
17353            marker: ::std::marker::PhantomData,
17354        }
17355    }
17356}
17357#[repr(transparent)]
17358pub struct SurfaceCapabilities2EXTBuilder<'a> {
17359    inner: SurfaceCapabilities2EXT,
17360    marker: ::std::marker::PhantomData<&'a ()>,
17361}
17362impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> {
17363    type Target = SurfaceCapabilities2EXT;
17364    fn deref(&self) -> &Self::Target {
17365        &self.inner
17366    }
17367}
17368impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> {
17369    fn deref_mut(&mut self) -> &mut Self::Target {
17370        &mut self.inner
17371    }
17372}
17373impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
17374    pub fn min_image_count(mut self, min_image_count: u32) -> Self {
17375        self.inner.min_image_count = min_image_count;
17376        self
17377    }
17378    pub fn max_image_count(mut self, max_image_count: u32) -> Self {
17379        self.inner.max_image_count = max_image_count;
17380        self
17381    }
17382    pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
17383        self.inner.current_extent = current_extent;
17384        self
17385    }
17386    pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
17387        self.inner.min_image_extent = min_image_extent;
17388        self
17389    }
17390    pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
17391        self.inner.max_image_extent = max_image_extent;
17392        self
17393    }
17394    pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
17395        self.inner.max_image_array_layers = max_image_array_layers;
17396        self
17397    }
17398    pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
17399        self.inner.supported_transforms = supported_transforms;
17400        self
17401    }
17402    pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
17403        self.inner.current_transform = current_transform;
17404        self
17405    }
17406    pub fn supported_composite_alpha(
17407        mut self,
17408        supported_composite_alpha: CompositeAlphaFlagsKHR,
17409    ) -> Self {
17410        self.inner.supported_composite_alpha = supported_composite_alpha;
17411        self
17412    }
17413    pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
17414        self.inner.supported_usage_flags = supported_usage_flags;
17415        self
17416    }
17417    pub fn supported_surface_counters(
17418        mut self,
17419        supported_surface_counters: SurfaceCounterFlagsEXT,
17420    ) -> Self {
17421        self.inner.supported_surface_counters = supported_surface_counters;
17422        self
17423    }
17424    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17425    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17426    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17427    pub fn build(self) -> SurfaceCapabilities2EXT {
17428        self.inner
17429    }
17430}
17431#[repr(C)]
17432#[cfg_attr(feature = "debug", derive(Debug))]
17433#[derive(Copy, Clone)]
17434#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPowerInfoEXT.html>"]
17435pub struct DisplayPowerInfoEXT {
17436    pub s_type: StructureType,
17437    pub p_next: *const c_void,
17438    pub power_state: DisplayPowerStateEXT,
17439}
17440impl ::std::default::Default for DisplayPowerInfoEXT {
17441    fn default() -> Self {
17442        Self {
17443            s_type: StructureType::DISPLAY_POWER_INFO_EXT,
17444            p_next: ::std::ptr::null(),
17445            power_state: DisplayPowerStateEXT::default(),
17446        }
17447    }
17448}
17449impl DisplayPowerInfoEXT {
17450    pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> {
17451        DisplayPowerInfoEXTBuilder {
17452            inner: Self::default(),
17453            marker: ::std::marker::PhantomData,
17454        }
17455    }
17456}
17457#[repr(transparent)]
17458pub struct DisplayPowerInfoEXTBuilder<'a> {
17459    inner: DisplayPowerInfoEXT,
17460    marker: ::std::marker::PhantomData<&'a ()>,
17461}
17462impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> {
17463    type Target = DisplayPowerInfoEXT;
17464    fn deref(&self) -> &Self::Target {
17465        &self.inner
17466    }
17467}
17468impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> {
17469    fn deref_mut(&mut self) -> &mut Self::Target {
17470        &mut self.inner
17471    }
17472}
17473impl<'a> DisplayPowerInfoEXTBuilder<'a> {
17474    pub fn power_state(mut self, power_state: DisplayPowerStateEXT) -> Self {
17475        self.inner.power_state = power_state;
17476        self
17477    }
17478    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17479    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17480    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17481    pub fn build(self) -> DisplayPowerInfoEXT {
17482        self.inner
17483    }
17484}
17485#[repr(C)]
17486#[cfg_attr(feature = "debug", derive(Debug))]
17487#[derive(Copy, Clone)]
17488#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceEventInfoEXT.html>"]
17489pub struct DeviceEventInfoEXT {
17490    pub s_type: StructureType,
17491    pub p_next: *const c_void,
17492    pub device_event: DeviceEventTypeEXT,
17493}
17494impl ::std::default::Default for DeviceEventInfoEXT {
17495    fn default() -> Self {
17496        Self {
17497            s_type: StructureType::DEVICE_EVENT_INFO_EXT,
17498            p_next: ::std::ptr::null(),
17499            device_event: DeviceEventTypeEXT::default(),
17500        }
17501    }
17502}
17503impl DeviceEventInfoEXT {
17504    pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> {
17505        DeviceEventInfoEXTBuilder {
17506            inner: Self::default(),
17507            marker: ::std::marker::PhantomData,
17508        }
17509    }
17510}
17511#[repr(transparent)]
17512pub struct DeviceEventInfoEXTBuilder<'a> {
17513    inner: DeviceEventInfoEXT,
17514    marker: ::std::marker::PhantomData<&'a ()>,
17515}
17516impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> {
17517    type Target = DeviceEventInfoEXT;
17518    fn deref(&self) -> &Self::Target {
17519        &self.inner
17520    }
17521}
17522impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> {
17523    fn deref_mut(&mut self) -> &mut Self::Target {
17524        &mut self.inner
17525    }
17526}
17527impl<'a> DeviceEventInfoEXTBuilder<'a> {
17528    pub fn device_event(mut self, device_event: DeviceEventTypeEXT) -> Self {
17529        self.inner.device_event = device_event;
17530        self
17531    }
17532    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17533    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17534    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17535    pub fn build(self) -> DeviceEventInfoEXT {
17536        self.inner
17537    }
17538}
17539#[repr(C)]
17540#[cfg_attr(feature = "debug", derive(Debug))]
17541#[derive(Copy, Clone)]
17542#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayEventInfoEXT.html>"]
17543pub struct DisplayEventInfoEXT {
17544    pub s_type: StructureType,
17545    pub p_next: *const c_void,
17546    pub display_event: DisplayEventTypeEXT,
17547}
17548impl ::std::default::Default for DisplayEventInfoEXT {
17549    fn default() -> Self {
17550        Self {
17551            s_type: StructureType::DISPLAY_EVENT_INFO_EXT,
17552            p_next: ::std::ptr::null(),
17553            display_event: DisplayEventTypeEXT::default(),
17554        }
17555    }
17556}
17557impl DisplayEventInfoEXT {
17558    pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> {
17559        DisplayEventInfoEXTBuilder {
17560            inner: Self::default(),
17561            marker: ::std::marker::PhantomData,
17562        }
17563    }
17564}
17565#[repr(transparent)]
17566pub struct DisplayEventInfoEXTBuilder<'a> {
17567    inner: DisplayEventInfoEXT,
17568    marker: ::std::marker::PhantomData<&'a ()>,
17569}
17570impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> {
17571    type Target = DisplayEventInfoEXT;
17572    fn deref(&self) -> &Self::Target {
17573        &self.inner
17574    }
17575}
17576impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> {
17577    fn deref_mut(&mut self) -> &mut Self::Target {
17578        &mut self.inner
17579    }
17580}
17581impl<'a> DisplayEventInfoEXTBuilder<'a> {
17582    pub fn display_event(mut self, display_event: DisplayEventTypeEXT) -> Self {
17583        self.inner.display_event = display_event;
17584        self
17585    }
17586    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17587    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17588    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17589    pub fn build(self) -> DisplayEventInfoEXT {
17590        self.inner
17591    }
17592}
17593#[repr(C)]
17594#[cfg_attr(feature = "debug", derive(Debug))]
17595#[derive(Copy, Clone)]
17596#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html>"]
17597pub struct SwapchainCounterCreateInfoEXT {
17598    pub s_type: StructureType,
17599    pub p_next: *const c_void,
17600    pub surface_counters: SurfaceCounterFlagsEXT,
17601}
17602impl ::std::default::Default for SwapchainCounterCreateInfoEXT {
17603    fn default() -> Self {
17604        Self {
17605            s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
17606            p_next: ::std::ptr::null(),
17607            surface_counters: SurfaceCounterFlagsEXT::default(),
17608        }
17609    }
17610}
17611impl SwapchainCounterCreateInfoEXT {
17612    pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> {
17613        SwapchainCounterCreateInfoEXTBuilder {
17614            inner: Self::default(),
17615            marker: ::std::marker::PhantomData,
17616        }
17617    }
17618}
17619#[repr(transparent)]
17620pub struct SwapchainCounterCreateInfoEXTBuilder<'a> {
17621    inner: SwapchainCounterCreateInfoEXT,
17622    marker: ::std::marker::PhantomData<&'a ()>,
17623}
17624unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {}
17625unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {}
17626impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> {
17627    type Target = SwapchainCounterCreateInfoEXT;
17628    fn deref(&self) -> &Self::Target {
17629        &self.inner
17630    }
17631}
17632impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> {
17633    fn deref_mut(&mut self) -> &mut Self::Target {
17634        &mut self.inner
17635    }
17636}
17637impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
17638    pub fn surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self {
17639        self.inner.surface_counters = surface_counters;
17640        self
17641    }
17642    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17643    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17644    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17645    pub fn build(self) -> SwapchainCounterCreateInfoEXT {
17646        self.inner
17647    }
17648}
17649#[repr(C)]
17650#[cfg_attr(feature = "debug", derive(Debug))]
17651#[derive(Copy, Clone)]
17652#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGroupProperties.html>"]
17653pub struct PhysicalDeviceGroupProperties {
17654    pub s_type: StructureType,
17655    pub p_next: *mut c_void,
17656    pub physical_device_count: u32,
17657    pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
17658    pub subset_allocation: Bool32,
17659}
17660impl ::std::default::Default for PhysicalDeviceGroupProperties {
17661    fn default() -> Self {
17662        Self {
17663            s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES,
17664            p_next: ::std::ptr::null_mut(),
17665            physical_device_count: u32::default(),
17666            physical_devices: unsafe { ::std::mem::zeroed() },
17667            subset_allocation: Bool32::default(),
17668        }
17669    }
17670}
17671impl PhysicalDeviceGroupProperties {
17672    pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> {
17673        PhysicalDeviceGroupPropertiesBuilder {
17674            inner: Self::default(),
17675            marker: ::std::marker::PhantomData,
17676        }
17677    }
17678}
17679#[repr(transparent)]
17680pub struct PhysicalDeviceGroupPropertiesBuilder<'a> {
17681    inner: PhysicalDeviceGroupProperties,
17682    marker: ::std::marker::PhantomData<&'a ()>,
17683}
17684impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> {
17685    type Target = PhysicalDeviceGroupProperties;
17686    fn deref(&self) -> &Self::Target {
17687        &self.inner
17688    }
17689}
17690impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> {
17691    fn deref_mut(&mut self) -> &mut Self::Target {
17692        &mut self.inner
17693    }
17694}
17695impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
17696    pub fn physical_device_count(mut self, physical_device_count: u32) -> Self {
17697        self.inner.physical_device_count = physical_device_count;
17698        self
17699    }
17700    pub fn physical_devices(
17701        mut self,
17702        physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
17703    ) -> Self {
17704        self.inner.physical_devices = physical_devices;
17705        self
17706    }
17707    pub fn subset_allocation(mut self, subset_allocation: bool) -> Self {
17708        self.inner.subset_allocation = subset_allocation.into();
17709        self
17710    }
17711    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17712    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17713    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17714    pub fn build(self) -> PhysicalDeviceGroupProperties {
17715        self.inner
17716    }
17717}
17718#[repr(C)]
17719#[cfg_attr(feature = "debug", derive(Debug))]
17720#[derive(Copy, Clone)]
17721#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagsInfo.html>"]
17722pub struct MemoryAllocateFlagsInfo {
17723    pub s_type: StructureType,
17724    pub p_next: *const c_void,
17725    pub flags: MemoryAllocateFlags,
17726    pub device_mask: u32,
17727}
17728impl ::std::default::Default for MemoryAllocateFlagsInfo {
17729    fn default() -> Self {
17730        Self {
17731            s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO,
17732            p_next: ::std::ptr::null(),
17733            flags: MemoryAllocateFlags::default(),
17734            device_mask: u32::default(),
17735        }
17736    }
17737}
17738impl MemoryAllocateFlagsInfo {
17739    pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> {
17740        MemoryAllocateFlagsInfoBuilder {
17741            inner: Self::default(),
17742            marker: ::std::marker::PhantomData,
17743        }
17744    }
17745}
17746#[repr(transparent)]
17747pub struct MemoryAllocateFlagsInfoBuilder<'a> {
17748    inner: MemoryAllocateFlagsInfo,
17749    marker: ::std::marker::PhantomData<&'a ()>,
17750}
17751unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {}
17752unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {}
17753impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> {
17754    type Target = MemoryAllocateFlagsInfo;
17755    fn deref(&self) -> &Self::Target {
17756        &self.inner
17757    }
17758}
17759impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> {
17760    fn deref_mut(&mut self) -> &mut Self::Target {
17761        &mut self.inner
17762    }
17763}
17764impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
17765    pub fn flags(mut self, flags: MemoryAllocateFlags) -> Self {
17766        self.inner.flags = flags;
17767        self
17768    }
17769    pub fn device_mask(mut self, device_mask: u32) -> Self {
17770        self.inner.device_mask = device_mask;
17771        self
17772    }
17773    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17774    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17775    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17776    pub fn build(self) -> MemoryAllocateFlagsInfo {
17777        self.inner
17778    }
17779}
17780#[repr(C)]
17781#[cfg_attr(feature = "debug", derive(Debug))]
17782#[derive(Copy, Clone)]
17783#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryInfo.html>"]
17784pub struct BindBufferMemoryInfo {
17785    pub s_type: StructureType,
17786    pub p_next: *const c_void,
17787    pub buffer: Buffer,
17788    pub memory: DeviceMemory,
17789    pub memory_offset: DeviceSize,
17790}
17791impl ::std::default::Default for BindBufferMemoryInfo {
17792    fn default() -> Self {
17793        Self {
17794            s_type: StructureType::BIND_BUFFER_MEMORY_INFO,
17795            p_next: ::std::ptr::null(),
17796            buffer: Buffer::default(),
17797            memory: DeviceMemory::default(),
17798            memory_offset: DeviceSize::default(),
17799        }
17800    }
17801}
17802impl BindBufferMemoryInfo {
17803    pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> {
17804        BindBufferMemoryInfoBuilder {
17805            inner: Self::default(),
17806            marker: ::std::marker::PhantomData,
17807        }
17808    }
17809}
17810#[repr(transparent)]
17811pub struct BindBufferMemoryInfoBuilder<'a> {
17812    inner: BindBufferMemoryInfo,
17813    marker: ::std::marker::PhantomData<&'a ()>,
17814}
17815pub unsafe trait ExtendsBindBufferMemoryInfo {}
17816impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> {
17817    type Target = BindBufferMemoryInfo;
17818    fn deref(&self) -> &Self::Target {
17819        &self.inner
17820    }
17821}
17822impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> {
17823    fn deref_mut(&mut self) -> &mut Self::Target {
17824        &mut self.inner
17825    }
17826}
17827impl<'a> BindBufferMemoryInfoBuilder<'a> {
17828    pub fn buffer(mut self, buffer: Buffer) -> Self {
17829        self.inner.buffer = buffer;
17830        self
17831    }
17832    pub fn memory(mut self, memory: DeviceMemory) -> Self {
17833        self.inner.memory = memory;
17834        self
17835    }
17836    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
17837        self.inner.memory_offset = memory_offset;
17838        self
17839    }
17840    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17841    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17842    #[doc = r" valid extension structs can be pushed into the chain."]
17843    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17844    #[doc = r" chain will look like `A -> D -> B -> C`."]
17845    pub fn push_next<T: ExtendsBindBufferMemoryInfo>(mut self, next: &'a mut T) -> Self {
17846        unsafe {
17847            let next_ptr = <*const T>::cast(next);
17848            let last_next = ptr_chain_iter(next).last().unwrap();
17849            (*last_next).p_next = self.inner.p_next as _;
17850            self.inner.p_next = next_ptr;
17851        }
17852        self
17853    }
17854    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17855    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17856    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17857    pub fn build(self) -> BindBufferMemoryInfo {
17858        self.inner
17859    }
17860}
17861#[repr(C)]
17862#[cfg_attr(feature = "debug", derive(Debug))]
17863#[derive(Copy, Clone)]
17864#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html>"]
17865pub struct BindBufferMemoryDeviceGroupInfo {
17866    pub s_type: StructureType,
17867    pub p_next: *const c_void,
17868    pub device_index_count: u32,
17869    pub p_device_indices: *const u32,
17870}
17871impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo {
17872    fn default() -> Self {
17873        Self {
17874            s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
17875            p_next: ::std::ptr::null(),
17876            device_index_count: u32::default(),
17877            p_device_indices: ::std::ptr::null(),
17878        }
17879    }
17880}
17881impl BindBufferMemoryDeviceGroupInfo {
17882    pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17883        BindBufferMemoryDeviceGroupInfoBuilder {
17884            inner: Self::default(),
17885            marker: ::std::marker::PhantomData,
17886        }
17887    }
17888}
17889#[repr(transparent)]
17890pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17891    inner: BindBufferMemoryDeviceGroupInfo,
17892    marker: ::std::marker::PhantomData<&'a ()>,
17893}
17894unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {}
17895unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {}
17896impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17897    type Target = BindBufferMemoryDeviceGroupInfo;
17898    fn deref(&self) -> &Self::Target {
17899        &self.inner
17900    }
17901}
17902impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17903    fn deref_mut(&mut self) -> &mut Self::Target {
17904        &mut self.inner
17905    }
17906}
17907impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
17908    pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
17909        self.inner.device_index_count = device_indices.len() as _;
17910        self.inner.p_device_indices = device_indices.as_ptr();
17911        self
17912    }
17913    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17914    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17915    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17916    pub fn build(self) -> BindBufferMemoryDeviceGroupInfo {
17917        self.inner
17918    }
17919}
17920#[repr(C)]
17921#[cfg_attr(feature = "debug", derive(Debug))]
17922#[derive(Copy, Clone)]
17923#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryInfo.html>"]
17924pub struct BindImageMemoryInfo {
17925    pub s_type: StructureType,
17926    pub p_next: *const c_void,
17927    pub image: Image,
17928    pub memory: DeviceMemory,
17929    pub memory_offset: DeviceSize,
17930}
17931impl ::std::default::Default for BindImageMemoryInfo {
17932    fn default() -> Self {
17933        Self {
17934            s_type: StructureType::BIND_IMAGE_MEMORY_INFO,
17935            p_next: ::std::ptr::null(),
17936            image: Image::default(),
17937            memory: DeviceMemory::default(),
17938            memory_offset: DeviceSize::default(),
17939        }
17940    }
17941}
17942impl BindImageMemoryInfo {
17943    pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> {
17944        BindImageMemoryInfoBuilder {
17945            inner: Self::default(),
17946            marker: ::std::marker::PhantomData,
17947        }
17948    }
17949}
17950#[repr(transparent)]
17951pub struct BindImageMemoryInfoBuilder<'a> {
17952    inner: BindImageMemoryInfo,
17953    marker: ::std::marker::PhantomData<&'a ()>,
17954}
17955pub unsafe trait ExtendsBindImageMemoryInfo {}
17956impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> {
17957    type Target = BindImageMemoryInfo;
17958    fn deref(&self) -> &Self::Target {
17959        &self.inner
17960    }
17961}
17962impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> {
17963    fn deref_mut(&mut self) -> &mut Self::Target {
17964        &mut self.inner
17965    }
17966}
17967impl<'a> BindImageMemoryInfoBuilder<'a> {
17968    pub fn image(mut self, image: Image) -> Self {
17969        self.inner.image = image;
17970        self
17971    }
17972    pub fn memory(mut self, memory: DeviceMemory) -> Self {
17973        self.inner.memory = memory;
17974        self
17975    }
17976    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
17977        self.inner.memory_offset = memory_offset;
17978        self
17979    }
17980    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17981    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17982    #[doc = r" valid extension structs can be pushed into the chain."]
17983    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17984    #[doc = r" chain will look like `A -> D -> B -> C`."]
17985    pub fn push_next<T: ExtendsBindImageMemoryInfo>(mut self, next: &'a mut T) -> Self {
17986        unsafe {
17987            let next_ptr = <*const T>::cast(next);
17988            let last_next = ptr_chain_iter(next).last().unwrap();
17989            (*last_next).p_next = self.inner.p_next as _;
17990            self.inner.p_next = next_ptr;
17991        }
17992        self
17993    }
17994    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17995    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17996    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
17997    pub fn build(self) -> BindImageMemoryInfo {
17998        self.inner
17999    }
18000}
18001#[repr(C)]
18002#[cfg_attr(feature = "debug", derive(Debug))]
18003#[derive(Copy, Clone)]
18004#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html>"]
18005pub struct BindImageMemoryDeviceGroupInfo {
18006    pub s_type: StructureType,
18007    pub p_next: *const c_void,
18008    pub device_index_count: u32,
18009    pub p_device_indices: *const u32,
18010    pub split_instance_bind_region_count: u32,
18011    pub p_split_instance_bind_regions: *const Rect2D,
18012}
18013impl ::std::default::Default for BindImageMemoryDeviceGroupInfo {
18014    fn default() -> Self {
18015        Self {
18016            s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
18017            p_next: ::std::ptr::null(),
18018            device_index_count: u32::default(),
18019            p_device_indices: ::std::ptr::null(),
18020            split_instance_bind_region_count: u32::default(),
18021            p_split_instance_bind_regions: ::std::ptr::null(),
18022        }
18023    }
18024}
18025impl BindImageMemoryDeviceGroupInfo {
18026    pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
18027        BindImageMemoryDeviceGroupInfoBuilder {
18028            inner: Self::default(),
18029            marker: ::std::marker::PhantomData,
18030        }
18031    }
18032}
18033#[repr(transparent)]
18034pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> {
18035    inner: BindImageMemoryDeviceGroupInfo,
18036    marker: ::std::marker::PhantomData<&'a ()>,
18037}
18038unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {}
18039unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {}
18040impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> {
18041    type Target = BindImageMemoryDeviceGroupInfo;
18042    fn deref(&self) -> &Self::Target {
18043        &self.inner
18044    }
18045}
18046impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> {
18047    fn deref_mut(&mut self) -> &mut Self::Target {
18048        &mut self.inner
18049    }
18050}
18051impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
18052    pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
18053        self.inner.device_index_count = device_indices.len() as _;
18054        self.inner.p_device_indices = device_indices.as_ptr();
18055        self
18056    }
18057    pub fn split_instance_bind_regions(
18058        mut self,
18059        split_instance_bind_regions: &'a [Rect2D],
18060    ) -> Self {
18061        self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _;
18062        self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr();
18063        self
18064    }
18065    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18066    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18067    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18068    pub fn build(self) -> BindImageMemoryDeviceGroupInfo {
18069        self.inner
18070    }
18071}
18072#[repr(C)]
18073#[cfg_attr(feature = "debug", derive(Debug))]
18074#[derive(Copy, Clone)]
18075#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html>"]
18076pub struct DeviceGroupRenderPassBeginInfo {
18077    pub s_type: StructureType,
18078    pub p_next: *const c_void,
18079    pub device_mask: u32,
18080    pub device_render_area_count: u32,
18081    pub p_device_render_areas: *const Rect2D,
18082}
18083impl ::std::default::Default for DeviceGroupRenderPassBeginInfo {
18084    fn default() -> Self {
18085        Self {
18086            s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
18087            p_next: ::std::ptr::null(),
18088            device_mask: u32::default(),
18089            device_render_area_count: u32::default(),
18090            p_device_render_areas: ::std::ptr::null(),
18091        }
18092    }
18093}
18094impl DeviceGroupRenderPassBeginInfo {
18095    pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
18096        DeviceGroupRenderPassBeginInfoBuilder {
18097            inner: Self::default(),
18098            marker: ::std::marker::PhantomData,
18099        }
18100    }
18101}
18102#[repr(transparent)]
18103pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
18104    inner: DeviceGroupRenderPassBeginInfo,
18105    marker: ::std::marker::PhantomData<&'a ()>,
18106}
18107unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
18108unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {}
18109unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
18110unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo {}
18111impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
18112    type Target = DeviceGroupRenderPassBeginInfo;
18113    fn deref(&self) -> &Self::Target {
18114        &self.inner
18115    }
18116}
18117impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> {
18118    fn deref_mut(&mut self) -> &mut Self::Target {
18119        &mut self.inner
18120    }
18121}
18122impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
18123    pub fn device_mask(mut self, device_mask: u32) -> Self {
18124        self.inner.device_mask = device_mask;
18125        self
18126    }
18127    pub fn device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self {
18128        self.inner.device_render_area_count = device_render_areas.len() as _;
18129        self.inner.p_device_render_areas = device_render_areas.as_ptr();
18130        self
18131    }
18132    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18133    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18134    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18135    pub fn build(self) -> DeviceGroupRenderPassBeginInfo {
18136        self.inner
18137    }
18138}
18139#[repr(C)]
18140#[cfg_attr(feature = "debug", derive(Debug))]
18141#[derive(Copy, Clone)]
18142#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html>"]
18143pub struct DeviceGroupCommandBufferBeginInfo {
18144    pub s_type: StructureType,
18145    pub p_next: *const c_void,
18146    pub device_mask: u32,
18147}
18148impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo {
18149    fn default() -> Self {
18150        Self {
18151            s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
18152            p_next: ::std::ptr::null(),
18153            device_mask: u32::default(),
18154        }
18155    }
18156}
18157impl DeviceGroupCommandBufferBeginInfo {
18158    pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18159        DeviceGroupCommandBufferBeginInfoBuilder {
18160            inner: Self::default(),
18161            marker: ::std::marker::PhantomData,
18162        }
18163    }
18164}
18165#[repr(transparent)]
18166pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18167    inner: DeviceGroupCommandBufferBeginInfo,
18168    marker: ::std::marker::PhantomData<&'a ()>,
18169}
18170unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {}
18171unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {}
18172impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18173    type Target = DeviceGroupCommandBufferBeginInfo;
18174    fn deref(&self) -> &Self::Target {
18175        &self.inner
18176    }
18177}
18178impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18179    fn deref_mut(&mut self) -> &mut Self::Target {
18180        &mut self.inner
18181    }
18182}
18183impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
18184    pub fn device_mask(mut self, device_mask: u32) -> Self {
18185        self.inner.device_mask = device_mask;
18186        self
18187    }
18188    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18189    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18190    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18191    pub fn build(self) -> DeviceGroupCommandBufferBeginInfo {
18192        self.inner
18193    }
18194}
18195#[repr(C)]
18196#[cfg_attr(feature = "debug", derive(Debug))]
18197#[derive(Copy, Clone)]
18198#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSubmitInfo.html>"]
18199pub struct DeviceGroupSubmitInfo {
18200    pub s_type: StructureType,
18201    pub p_next: *const c_void,
18202    pub wait_semaphore_count: u32,
18203    pub p_wait_semaphore_device_indices: *const u32,
18204    pub command_buffer_count: u32,
18205    pub p_command_buffer_device_masks: *const u32,
18206    pub signal_semaphore_count: u32,
18207    pub p_signal_semaphore_device_indices: *const u32,
18208}
18209impl ::std::default::Default for DeviceGroupSubmitInfo {
18210    fn default() -> Self {
18211        Self {
18212            s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO,
18213            p_next: ::std::ptr::null(),
18214            wait_semaphore_count: u32::default(),
18215            p_wait_semaphore_device_indices: ::std::ptr::null(),
18216            command_buffer_count: u32::default(),
18217            p_command_buffer_device_masks: ::std::ptr::null(),
18218            signal_semaphore_count: u32::default(),
18219            p_signal_semaphore_device_indices: ::std::ptr::null(),
18220        }
18221    }
18222}
18223impl DeviceGroupSubmitInfo {
18224    pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> {
18225        DeviceGroupSubmitInfoBuilder {
18226            inner: Self::default(),
18227            marker: ::std::marker::PhantomData,
18228        }
18229    }
18230}
18231#[repr(transparent)]
18232pub struct DeviceGroupSubmitInfoBuilder<'a> {
18233    inner: DeviceGroupSubmitInfo,
18234    marker: ::std::marker::PhantomData<&'a ()>,
18235}
18236unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {}
18237unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {}
18238impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> {
18239    type Target = DeviceGroupSubmitInfo;
18240    fn deref(&self) -> &Self::Target {
18241        &self.inner
18242    }
18243}
18244impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> {
18245    fn deref_mut(&mut self) -> &mut Self::Target {
18246        &mut self.inner
18247    }
18248}
18249impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
18250    pub fn wait_semaphore_device_indices(
18251        mut self,
18252        wait_semaphore_device_indices: &'a [u32],
18253    ) -> Self {
18254        self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _;
18255        self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr();
18256        self
18257    }
18258    pub fn command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self {
18259        self.inner.command_buffer_count = command_buffer_device_masks.len() as _;
18260        self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr();
18261        self
18262    }
18263    pub fn signal_semaphore_device_indices(
18264        mut self,
18265        signal_semaphore_device_indices: &'a [u32],
18266    ) -> Self {
18267        self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _;
18268        self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr();
18269        self
18270    }
18271    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18272    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18273    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18274    pub fn build(self) -> DeviceGroupSubmitInfo {
18275        self.inner
18276    }
18277}
18278#[repr(C)]
18279#[cfg_attr(feature = "debug", derive(Debug))]
18280#[derive(Copy, Clone)]
18281#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupBindSparseInfo.html>"]
18282pub struct DeviceGroupBindSparseInfo {
18283    pub s_type: StructureType,
18284    pub p_next: *const c_void,
18285    pub resource_device_index: u32,
18286    pub memory_device_index: u32,
18287}
18288impl ::std::default::Default for DeviceGroupBindSparseInfo {
18289    fn default() -> Self {
18290        Self {
18291            s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO,
18292            p_next: ::std::ptr::null(),
18293            resource_device_index: u32::default(),
18294            memory_device_index: u32::default(),
18295        }
18296    }
18297}
18298impl DeviceGroupBindSparseInfo {
18299    pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> {
18300        DeviceGroupBindSparseInfoBuilder {
18301            inner: Self::default(),
18302            marker: ::std::marker::PhantomData,
18303        }
18304    }
18305}
18306#[repr(transparent)]
18307pub struct DeviceGroupBindSparseInfoBuilder<'a> {
18308    inner: DeviceGroupBindSparseInfo,
18309    marker: ::std::marker::PhantomData<&'a ()>,
18310}
18311unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {}
18312unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {}
18313impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> {
18314    type Target = DeviceGroupBindSparseInfo;
18315    fn deref(&self) -> &Self::Target {
18316        &self.inner
18317    }
18318}
18319impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> {
18320    fn deref_mut(&mut self) -> &mut Self::Target {
18321        &mut self.inner
18322    }
18323}
18324impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
18325    pub fn resource_device_index(mut self, resource_device_index: u32) -> Self {
18326        self.inner.resource_device_index = resource_device_index;
18327        self
18328    }
18329    pub fn memory_device_index(mut self, memory_device_index: u32) -> Self {
18330        self.inner.memory_device_index = memory_device_index;
18331        self
18332    }
18333    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18334    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18335    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18336    pub fn build(self) -> DeviceGroupBindSparseInfo {
18337        self.inner
18338    }
18339}
18340#[repr(C)]
18341#[cfg_attr(feature = "debug", derive(Debug))]
18342#[derive(Copy, Clone)]
18343#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>"]
18344pub struct DeviceGroupPresentCapabilitiesKHR {
18345    pub s_type: StructureType,
18346    pub p_next: *mut c_void,
18347    pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
18348    pub modes: DeviceGroupPresentModeFlagsKHR,
18349}
18350impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR {
18351    fn default() -> Self {
18352        Self {
18353            s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
18354            p_next: ::std::ptr::null_mut(),
18355            present_mask: unsafe { ::std::mem::zeroed() },
18356            modes: DeviceGroupPresentModeFlagsKHR::default(),
18357        }
18358    }
18359}
18360impl DeviceGroupPresentCapabilitiesKHR {
18361    pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18362        DeviceGroupPresentCapabilitiesKHRBuilder {
18363            inner: Self::default(),
18364            marker: ::std::marker::PhantomData,
18365        }
18366    }
18367}
18368#[repr(transparent)]
18369pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18370    inner: DeviceGroupPresentCapabilitiesKHR,
18371    marker: ::std::marker::PhantomData<&'a ()>,
18372}
18373impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18374    type Target = DeviceGroupPresentCapabilitiesKHR;
18375    fn deref(&self) -> &Self::Target {
18376        &self.inner
18377    }
18378}
18379impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18380    fn deref_mut(&mut self) -> &mut Self::Target {
18381        &mut self.inner
18382    }
18383}
18384impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
18385    pub fn present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self {
18386        self.inner.present_mask = present_mask;
18387        self
18388    }
18389    pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
18390        self.inner.modes = modes;
18391        self
18392    }
18393    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18394    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18395    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18396    pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR {
18397        self.inner
18398    }
18399}
18400#[repr(C)]
18401#[cfg_attr(feature = "debug", derive(Debug))]
18402#[derive(Copy, Clone)]
18403#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSwapchainCreateInfoKHR.html>"]
18404pub struct ImageSwapchainCreateInfoKHR {
18405    pub s_type: StructureType,
18406    pub p_next: *const c_void,
18407    pub swapchain: SwapchainKHR,
18408}
18409impl ::std::default::Default for ImageSwapchainCreateInfoKHR {
18410    fn default() -> Self {
18411        Self {
18412            s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
18413            p_next: ::std::ptr::null(),
18414            swapchain: SwapchainKHR::default(),
18415        }
18416    }
18417}
18418impl ImageSwapchainCreateInfoKHR {
18419    pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> {
18420        ImageSwapchainCreateInfoKHRBuilder {
18421            inner: Self::default(),
18422            marker: ::std::marker::PhantomData,
18423        }
18424    }
18425}
18426#[repr(transparent)]
18427pub struct ImageSwapchainCreateInfoKHRBuilder<'a> {
18428    inner: ImageSwapchainCreateInfoKHR,
18429    marker: ::std::marker::PhantomData<&'a ()>,
18430}
18431unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {}
18432unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {}
18433impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> {
18434    type Target = ImageSwapchainCreateInfoKHR;
18435    fn deref(&self) -> &Self::Target {
18436        &self.inner
18437    }
18438}
18439impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> {
18440    fn deref_mut(&mut self) -> &mut Self::Target {
18441        &mut self.inner
18442    }
18443}
18444impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
18445    pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
18446        self.inner.swapchain = swapchain;
18447        self
18448    }
18449    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18450    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18451    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18452    pub fn build(self) -> ImageSwapchainCreateInfoKHR {
18453        self.inner
18454    }
18455}
18456#[repr(C)]
18457#[cfg_attr(feature = "debug", derive(Debug))]
18458#[derive(Copy, Clone)]
18459#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html>"]
18460pub struct BindImageMemorySwapchainInfoKHR {
18461    pub s_type: StructureType,
18462    pub p_next: *const c_void,
18463    pub swapchain: SwapchainKHR,
18464    pub image_index: u32,
18465}
18466impl ::std::default::Default for BindImageMemorySwapchainInfoKHR {
18467    fn default() -> Self {
18468        Self {
18469            s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
18470            p_next: ::std::ptr::null(),
18471            swapchain: SwapchainKHR::default(),
18472            image_index: u32::default(),
18473        }
18474    }
18475}
18476impl BindImageMemorySwapchainInfoKHR {
18477    pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
18478        BindImageMemorySwapchainInfoKHRBuilder {
18479            inner: Self::default(),
18480            marker: ::std::marker::PhantomData,
18481        }
18482    }
18483}
18484#[repr(transparent)]
18485pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> {
18486    inner: BindImageMemorySwapchainInfoKHR,
18487    marker: ::std::marker::PhantomData<&'a ()>,
18488}
18489unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {}
18490unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {}
18491impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> {
18492    type Target = BindImageMemorySwapchainInfoKHR;
18493    fn deref(&self) -> &Self::Target {
18494        &self.inner
18495    }
18496}
18497impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> {
18498    fn deref_mut(&mut self) -> &mut Self::Target {
18499        &mut self.inner
18500    }
18501}
18502impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
18503    pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
18504        self.inner.swapchain = swapchain;
18505        self
18506    }
18507    pub fn image_index(mut self, image_index: u32) -> Self {
18508        self.inner.image_index = image_index;
18509        self
18510    }
18511    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18512    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18513    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18514    pub fn build(self) -> BindImageMemorySwapchainInfoKHR {
18515        self.inner
18516    }
18517}
18518#[repr(C)]
18519#[cfg_attr(feature = "debug", derive(Debug))]
18520#[derive(Copy, Clone)]
18521#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireNextImageInfoKHR.html>"]
18522pub struct AcquireNextImageInfoKHR {
18523    pub s_type: StructureType,
18524    pub p_next: *const c_void,
18525    pub swapchain: SwapchainKHR,
18526    pub timeout: u64,
18527    pub semaphore: Semaphore,
18528    pub fence: Fence,
18529    pub device_mask: u32,
18530}
18531impl ::std::default::Default for AcquireNextImageInfoKHR {
18532    fn default() -> Self {
18533        Self {
18534            s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR,
18535            p_next: ::std::ptr::null(),
18536            swapchain: SwapchainKHR::default(),
18537            timeout: u64::default(),
18538            semaphore: Semaphore::default(),
18539            fence: Fence::default(),
18540            device_mask: u32::default(),
18541        }
18542    }
18543}
18544impl AcquireNextImageInfoKHR {
18545    pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> {
18546        AcquireNextImageInfoKHRBuilder {
18547            inner: Self::default(),
18548            marker: ::std::marker::PhantomData,
18549        }
18550    }
18551}
18552#[repr(transparent)]
18553pub struct AcquireNextImageInfoKHRBuilder<'a> {
18554    inner: AcquireNextImageInfoKHR,
18555    marker: ::std::marker::PhantomData<&'a ()>,
18556}
18557impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> {
18558    type Target = AcquireNextImageInfoKHR;
18559    fn deref(&self) -> &Self::Target {
18560        &self.inner
18561    }
18562}
18563impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> {
18564    fn deref_mut(&mut self) -> &mut Self::Target {
18565        &mut self.inner
18566    }
18567}
18568impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
18569    pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
18570        self.inner.swapchain = swapchain;
18571        self
18572    }
18573    pub fn timeout(mut self, timeout: u64) -> Self {
18574        self.inner.timeout = timeout;
18575        self
18576    }
18577    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
18578        self.inner.semaphore = semaphore;
18579        self
18580    }
18581    pub fn fence(mut self, fence: Fence) -> Self {
18582        self.inner.fence = fence;
18583        self
18584    }
18585    pub fn device_mask(mut self, device_mask: u32) -> Self {
18586        self.inner.device_mask = device_mask;
18587        self
18588    }
18589    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18590    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18591    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18592    pub fn build(self) -> AcquireNextImageInfoKHR {
18593        self.inner
18594    }
18595}
18596#[repr(C)]
18597#[cfg_attr(feature = "debug", derive(Debug))]
18598#[derive(Copy, Clone)]
18599#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentInfoKHR.html>"]
18600pub struct DeviceGroupPresentInfoKHR {
18601    pub s_type: StructureType,
18602    pub p_next: *const c_void,
18603    pub swapchain_count: u32,
18604    pub p_device_masks: *const u32,
18605    pub mode: DeviceGroupPresentModeFlagsKHR,
18606}
18607impl ::std::default::Default for DeviceGroupPresentInfoKHR {
18608    fn default() -> Self {
18609        Self {
18610            s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR,
18611            p_next: ::std::ptr::null(),
18612            swapchain_count: u32::default(),
18613            p_device_masks: ::std::ptr::null(),
18614            mode: DeviceGroupPresentModeFlagsKHR::default(),
18615        }
18616    }
18617}
18618impl DeviceGroupPresentInfoKHR {
18619    pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> {
18620        DeviceGroupPresentInfoKHRBuilder {
18621            inner: Self::default(),
18622            marker: ::std::marker::PhantomData,
18623        }
18624    }
18625}
18626#[repr(transparent)]
18627pub struct DeviceGroupPresentInfoKHRBuilder<'a> {
18628    inner: DeviceGroupPresentInfoKHR,
18629    marker: ::std::marker::PhantomData<&'a ()>,
18630}
18631unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {}
18632unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {}
18633impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> {
18634    type Target = DeviceGroupPresentInfoKHR;
18635    fn deref(&self) -> &Self::Target {
18636        &self.inner
18637    }
18638}
18639impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> {
18640    fn deref_mut(&mut self) -> &mut Self::Target {
18641        &mut self.inner
18642    }
18643}
18644impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
18645    pub fn device_masks(mut self, device_masks: &'a [u32]) -> Self {
18646        self.inner.swapchain_count = device_masks.len() as _;
18647        self.inner.p_device_masks = device_masks.as_ptr();
18648        self
18649    }
18650    pub fn mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self {
18651        self.inner.mode = mode;
18652        self
18653    }
18654    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18655    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18656    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18657    pub fn build(self) -> DeviceGroupPresentInfoKHR {
18658        self.inner
18659    }
18660}
18661#[repr(C)]
18662#[cfg_attr(feature = "debug", derive(Debug))]
18663#[derive(Copy, Clone)]
18664#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html>"]
18665pub struct DeviceGroupDeviceCreateInfo {
18666    pub s_type: StructureType,
18667    pub p_next: *const c_void,
18668    pub physical_device_count: u32,
18669    pub p_physical_devices: *const PhysicalDevice,
18670}
18671impl ::std::default::Default for DeviceGroupDeviceCreateInfo {
18672    fn default() -> Self {
18673        Self {
18674            s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO,
18675            p_next: ::std::ptr::null(),
18676            physical_device_count: u32::default(),
18677            p_physical_devices: ::std::ptr::null(),
18678        }
18679    }
18680}
18681impl DeviceGroupDeviceCreateInfo {
18682    pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> {
18683        DeviceGroupDeviceCreateInfoBuilder {
18684            inner: Self::default(),
18685            marker: ::std::marker::PhantomData,
18686        }
18687    }
18688}
18689#[repr(transparent)]
18690pub struct DeviceGroupDeviceCreateInfoBuilder<'a> {
18691    inner: DeviceGroupDeviceCreateInfo,
18692    marker: ::std::marker::PhantomData<&'a ()>,
18693}
18694unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {}
18695unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {}
18696impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> {
18697    type Target = DeviceGroupDeviceCreateInfo;
18698    fn deref(&self) -> &Self::Target {
18699        &self.inner
18700    }
18701}
18702impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> {
18703    fn deref_mut(&mut self) -> &mut Self::Target {
18704        &mut self.inner
18705    }
18706}
18707impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
18708    pub fn physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self {
18709        self.inner.physical_device_count = physical_devices.len() as _;
18710        self.inner.p_physical_devices = physical_devices.as_ptr();
18711        self
18712    }
18713    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18714    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18715    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18716    pub fn build(self) -> DeviceGroupDeviceCreateInfo {
18717        self.inner
18718    }
18719}
18720#[repr(C)]
18721#[cfg_attr(feature = "debug", derive(Debug))]
18722#[derive(Copy, Clone)]
18723#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>"]
18724pub struct DeviceGroupSwapchainCreateInfoKHR {
18725    pub s_type: StructureType,
18726    pub p_next: *const c_void,
18727    pub modes: DeviceGroupPresentModeFlagsKHR,
18728}
18729impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR {
18730    fn default() -> Self {
18731        Self {
18732            s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
18733            p_next: ::std::ptr::null(),
18734            modes: DeviceGroupPresentModeFlagsKHR::default(),
18735        }
18736    }
18737}
18738impl DeviceGroupSwapchainCreateInfoKHR {
18739    pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18740        DeviceGroupSwapchainCreateInfoKHRBuilder {
18741            inner: Self::default(),
18742            marker: ::std::marker::PhantomData,
18743        }
18744    }
18745}
18746#[repr(transparent)]
18747pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18748    inner: DeviceGroupSwapchainCreateInfoKHR,
18749    marker: ::std::marker::PhantomData<&'a ()>,
18750}
18751unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {}
18752unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {}
18753impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18754    type Target = DeviceGroupSwapchainCreateInfoKHR;
18755    fn deref(&self) -> &Self::Target {
18756        &self.inner
18757    }
18758}
18759impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18760    fn deref_mut(&mut self) -> &mut Self::Target {
18761        &mut self.inner
18762    }
18763}
18764impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
18765    pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
18766        self.inner.modes = modes;
18767        self
18768    }
18769    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18770    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18771    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18772    pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR {
18773        self.inner
18774    }
18775}
18776#[repr(C)]
18777#[cfg_attr(feature = "debug", derive(Debug))]
18778#[derive(Copy, Clone, Default)]
18779#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateEntry.html>"]
18780pub struct DescriptorUpdateTemplateEntry {
18781    pub dst_binding: u32,
18782    pub dst_array_element: u32,
18783    pub descriptor_count: u32,
18784    pub descriptor_type: DescriptorType,
18785    pub offset: usize,
18786    pub stride: usize,
18787}
18788impl DescriptorUpdateTemplateEntry {
18789    pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> {
18790        DescriptorUpdateTemplateEntryBuilder {
18791            inner: Self::default(),
18792            marker: ::std::marker::PhantomData,
18793        }
18794    }
18795}
18796#[repr(transparent)]
18797pub struct DescriptorUpdateTemplateEntryBuilder<'a> {
18798    inner: DescriptorUpdateTemplateEntry,
18799    marker: ::std::marker::PhantomData<&'a ()>,
18800}
18801impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> {
18802    type Target = DescriptorUpdateTemplateEntry;
18803    fn deref(&self) -> &Self::Target {
18804        &self.inner
18805    }
18806}
18807impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> {
18808    fn deref_mut(&mut self) -> &mut Self::Target {
18809        &mut self.inner
18810    }
18811}
18812impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> {
18813    pub fn dst_binding(mut self, dst_binding: u32) -> Self {
18814        self.inner.dst_binding = dst_binding;
18815        self
18816    }
18817    pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
18818        self.inner.dst_array_element = dst_array_element;
18819        self
18820    }
18821    pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
18822        self.inner.descriptor_count = descriptor_count;
18823        self
18824    }
18825    pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
18826        self.inner.descriptor_type = descriptor_type;
18827        self
18828    }
18829    pub fn offset(mut self, offset: usize) -> Self {
18830        self.inner.offset = offset;
18831        self
18832    }
18833    pub fn stride(mut self, stride: usize) -> Self {
18834        self.inner.stride = stride;
18835        self
18836    }
18837    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18838    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18839    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18840    pub fn build(self) -> DescriptorUpdateTemplateEntry {
18841        self.inner
18842    }
18843}
18844#[repr(C)]
18845#[cfg_attr(feature = "debug", derive(Debug))]
18846#[derive(Copy, Clone)]
18847#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html>"]
18848pub struct DescriptorUpdateTemplateCreateInfo {
18849    pub s_type: StructureType,
18850    pub p_next: *const c_void,
18851    pub flags: DescriptorUpdateTemplateCreateFlags,
18852    pub descriptor_update_entry_count: u32,
18853    pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry,
18854    pub template_type: DescriptorUpdateTemplateType,
18855    pub descriptor_set_layout: DescriptorSetLayout,
18856    pub pipeline_bind_point: PipelineBindPoint,
18857    pub pipeline_layout: PipelineLayout,
18858    pub set: u32,
18859}
18860impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo {
18861    fn default() -> Self {
18862        Self {
18863            s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
18864            p_next: ::std::ptr::null(),
18865            flags: DescriptorUpdateTemplateCreateFlags::default(),
18866            descriptor_update_entry_count: u32::default(),
18867            p_descriptor_update_entries: ::std::ptr::null(),
18868            template_type: DescriptorUpdateTemplateType::default(),
18869            descriptor_set_layout: DescriptorSetLayout::default(),
18870            pipeline_bind_point: PipelineBindPoint::default(),
18871            pipeline_layout: PipelineLayout::default(),
18872            set: u32::default(),
18873        }
18874    }
18875}
18876impl DescriptorUpdateTemplateCreateInfo {
18877    pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18878        DescriptorUpdateTemplateCreateInfoBuilder {
18879            inner: Self::default(),
18880            marker: ::std::marker::PhantomData,
18881        }
18882    }
18883}
18884#[repr(transparent)]
18885pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18886    inner: DescriptorUpdateTemplateCreateInfo,
18887    marker: ::std::marker::PhantomData<&'a ()>,
18888}
18889impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18890    type Target = DescriptorUpdateTemplateCreateInfo;
18891    fn deref(&self) -> &Self::Target {
18892        &self.inner
18893    }
18894}
18895impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18896    fn deref_mut(&mut self) -> &mut Self::Target {
18897        &mut self.inner
18898    }
18899}
18900impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
18901    pub fn flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self {
18902        self.inner.flags = flags;
18903        self
18904    }
18905    pub fn descriptor_update_entries(
18906        mut self,
18907        descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry],
18908    ) -> Self {
18909        self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _;
18910        self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr();
18911        self
18912    }
18913    pub fn template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self {
18914        self.inner.template_type = template_type;
18915        self
18916    }
18917    pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
18918        self.inner.descriptor_set_layout = descriptor_set_layout;
18919        self
18920    }
18921    pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
18922        self.inner.pipeline_bind_point = pipeline_bind_point;
18923        self
18924    }
18925    pub fn pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self {
18926        self.inner.pipeline_layout = pipeline_layout;
18927        self
18928    }
18929    pub fn set(mut self, set: u32) -> Self {
18930        self.inner.set = set;
18931        self
18932    }
18933    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18934    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18935    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18936    pub fn build(self) -> DescriptorUpdateTemplateCreateInfo {
18937        self.inner
18938    }
18939}
18940#[repr(C)]
18941#[cfg_attr(feature = "debug", derive(Debug))]
18942#[derive(Copy, Clone, Default)]
18943#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXYColorEXT.html>"]
18944pub struct XYColorEXT {
18945    pub x: f32,
18946    pub y: f32,
18947}
18948impl XYColorEXT {
18949    pub fn builder<'a>() -> XYColorEXTBuilder<'a> {
18950        XYColorEXTBuilder {
18951            inner: Self::default(),
18952            marker: ::std::marker::PhantomData,
18953        }
18954    }
18955}
18956#[repr(transparent)]
18957pub struct XYColorEXTBuilder<'a> {
18958    inner: XYColorEXT,
18959    marker: ::std::marker::PhantomData<&'a ()>,
18960}
18961impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> {
18962    type Target = XYColorEXT;
18963    fn deref(&self) -> &Self::Target {
18964        &self.inner
18965    }
18966}
18967impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> {
18968    fn deref_mut(&mut self) -> &mut Self::Target {
18969        &mut self.inner
18970    }
18971}
18972impl<'a> XYColorEXTBuilder<'a> {
18973    pub fn x(mut self, x: f32) -> Self {
18974        self.inner.x = x;
18975        self
18976    }
18977    pub fn y(mut self, y: f32) -> Self {
18978        self.inner.y = y;
18979        self
18980    }
18981    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18982    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18983    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
18984    pub fn build(self) -> XYColorEXT {
18985        self.inner
18986    }
18987}
18988#[repr(C)]
18989#[cfg_attr(feature = "debug", derive(Debug))]
18990#[derive(Copy, Clone)]
18991#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>"]
18992pub struct PhysicalDevicePresentIdFeaturesKHR {
18993    pub s_type: StructureType,
18994    pub p_next: *mut c_void,
18995    pub present_id: Bool32,
18996}
18997impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR {
18998    fn default() -> Self {
18999        Self {
19000            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR,
19001            p_next: ::std::ptr::null_mut(),
19002            present_id: Bool32::default(),
19003        }
19004    }
19005}
19006impl PhysicalDevicePresentIdFeaturesKHR {
19007    pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19008        PhysicalDevicePresentIdFeaturesKHRBuilder {
19009            inner: Self::default(),
19010            marker: ::std::marker::PhantomData,
19011        }
19012    }
19013}
19014#[repr(transparent)]
19015pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19016    inner: PhysicalDevicePresentIdFeaturesKHR,
19017    marker: ::std::marker::PhantomData<&'a ()>,
19018}
19019unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
19020unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {}
19021unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
19022unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {}
19023impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19024    type Target = PhysicalDevicePresentIdFeaturesKHR;
19025    fn deref(&self) -> &Self::Target {
19026        &self.inner
19027    }
19028}
19029impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19030    fn deref_mut(&mut self) -> &mut Self::Target {
19031        &mut self.inner
19032    }
19033}
19034impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
19035    pub fn present_id(mut self, present_id: bool) -> Self {
19036        self.inner.present_id = present_id.into();
19037        self
19038    }
19039    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19040    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19041    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19042    pub fn build(self) -> PhysicalDevicePresentIdFeaturesKHR {
19043        self.inner
19044    }
19045}
19046#[repr(C)]
19047#[cfg_attr(feature = "debug", derive(Debug))]
19048#[derive(Copy, Clone)]
19049#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentIdKHR.html>"]
19050pub struct PresentIdKHR {
19051    pub s_type: StructureType,
19052    pub p_next: *const c_void,
19053    pub swapchain_count: u32,
19054    pub p_present_ids: *const u64,
19055}
19056impl ::std::default::Default for PresentIdKHR {
19057    fn default() -> Self {
19058        Self {
19059            s_type: StructureType::PRESENT_ID_KHR,
19060            p_next: ::std::ptr::null(),
19061            swapchain_count: u32::default(),
19062            p_present_ids: ::std::ptr::null(),
19063        }
19064    }
19065}
19066impl PresentIdKHR {
19067    pub fn builder<'a>() -> PresentIdKHRBuilder<'a> {
19068        PresentIdKHRBuilder {
19069            inner: Self::default(),
19070            marker: ::std::marker::PhantomData,
19071        }
19072    }
19073}
19074#[repr(transparent)]
19075pub struct PresentIdKHRBuilder<'a> {
19076    inner: PresentIdKHR,
19077    marker: ::std::marker::PhantomData<&'a ()>,
19078}
19079unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {}
19080unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {}
19081impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> {
19082    type Target = PresentIdKHR;
19083    fn deref(&self) -> &Self::Target {
19084        &self.inner
19085    }
19086}
19087impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> {
19088    fn deref_mut(&mut self) -> &mut Self::Target {
19089        &mut self.inner
19090    }
19091}
19092impl<'a> PresentIdKHRBuilder<'a> {
19093    pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self {
19094        self.inner.swapchain_count = present_ids.len() as _;
19095        self.inner.p_present_ids = present_ids.as_ptr();
19096        self
19097    }
19098    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19099    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19100    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19101    pub fn build(self) -> PresentIdKHR {
19102        self.inner
19103    }
19104}
19105#[repr(C)]
19106#[cfg_attr(feature = "debug", derive(Debug))]
19107#[derive(Copy, Clone)]
19108#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>"]
19109pub struct PhysicalDevicePresentWaitFeaturesKHR {
19110    pub s_type: StructureType,
19111    pub p_next: *mut c_void,
19112    pub present_wait: Bool32,
19113}
19114impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR {
19115    fn default() -> Self {
19116        Self {
19117            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR,
19118            p_next: ::std::ptr::null_mut(),
19119            present_wait: Bool32::default(),
19120        }
19121    }
19122}
19123impl PhysicalDevicePresentWaitFeaturesKHR {
19124    pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19125        PhysicalDevicePresentWaitFeaturesKHRBuilder {
19126            inner: Self::default(),
19127            marker: ::std::marker::PhantomData,
19128        }
19129    }
19130}
19131#[repr(transparent)]
19132pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19133    inner: PhysicalDevicePresentWaitFeaturesKHR,
19134    marker: ::std::marker::PhantomData<&'a ()>,
19135}
19136unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
19137unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {}
19138unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
19139unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {}
19140impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19141    type Target = PhysicalDevicePresentWaitFeaturesKHR;
19142    fn deref(&self) -> &Self::Target {
19143        &self.inner
19144    }
19145}
19146impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19147    fn deref_mut(&mut self) -> &mut Self::Target {
19148        &mut self.inner
19149    }
19150}
19151impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
19152    pub fn present_wait(mut self, present_wait: bool) -> Self {
19153        self.inner.present_wait = present_wait.into();
19154        self
19155    }
19156    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19157    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19158    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19159    pub fn build(self) -> PhysicalDevicePresentWaitFeaturesKHR {
19160        self.inner
19161    }
19162}
19163#[repr(C)]
19164#[cfg_attr(feature = "debug", derive(Debug))]
19165#[derive(Copy, Clone)]
19166#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHdrMetadataEXT.html>"]
19167pub struct HdrMetadataEXT {
19168    pub s_type: StructureType,
19169    pub p_next: *const c_void,
19170    pub display_primary_red: XYColorEXT,
19171    pub display_primary_green: XYColorEXT,
19172    pub display_primary_blue: XYColorEXT,
19173    pub white_point: XYColorEXT,
19174    pub max_luminance: f32,
19175    pub min_luminance: f32,
19176    pub max_content_light_level: f32,
19177    pub max_frame_average_light_level: f32,
19178}
19179impl ::std::default::Default for HdrMetadataEXT {
19180    fn default() -> Self {
19181        Self {
19182            s_type: StructureType::HDR_METADATA_EXT,
19183            p_next: ::std::ptr::null(),
19184            display_primary_red: XYColorEXT::default(),
19185            display_primary_green: XYColorEXT::default(),
19186            display_primary_blue: XYColorEXT::default(),
19187            white_point: XYColorEXT::default(),
19188            max_luminance: f32::default(),
19189            min_luminance: f32::default(),
19190            max_content_light_level: f32::default(),
19191            max_frame_average_light_level: f32::default(),
19192        }
19193    }
19194}
19195impl HdrMetadataEXT {
19196    pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> {
19197        HdrMetadataEXTBuilder {
19198            inner: Self::default(),
19199            marker: ::std::marker::PhantomData,
19200        }
19201    }
19202}
19203#[repr(transparent)]
19204pub struct HdrMetadataEXTBuilder<'a> {
19205    inner: HdrMetadataEXT,
19206    marker: ::std::marker::PhantomData<&'a ()>,
19207}
19208impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> {
19209    type Target = HdrMetadataEXT;
19210    fn deref(&self) -> &Self::Target {
19211        &self.inner
19212    }
19213}
19214impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> {
19215    fn deref_mut(&mut self) -> &mut Self::Target {
19216        &mut self.inner
19217    }
19218}
19219impl<'a> HdrMetadataEXTBuilder<'a> {
19220    pub fn display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self {
19221        self.inner.display_primary_red = display_primary_red;
19222        self
19223    }
19224    pub fn display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self {
19225        self.inner.display_primary_green = display_primary_green;
19226        self
19227    }
19228    pub fn display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self {
19229        self.inner.display_primary_blue = display_primary_blue;
19230        self
19231    }
19232    pub fn white_point(mut self, white_point: XYColorEXT) -> Self {
19233        self.inner.white_point = white_point;
19234        self
19235    }
19236    pub fn max_luminance(mut self, max_luminance: f32) -> Self {
19237        self.inner.max_luminance = max_luminance;
19238        self
19239    }
19240    pub fn min_luminance(mut self, min_luminance: f32) -> Self {
19241        self.inner.min_luminance = min_luminance;
19242        self
19243    }
19244    pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self {
19245        self.inner.max_content_light_level = max_content_light_level;
19246        self
19247    }
19248    pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self {
19249        self.inner.max_frame_average_light_level = max_frame_average_light_level;
19250        self
19251    }
19252    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19253    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19254    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19255    pub fn build(self) -> HdrMetadataEXT {
19256        self.inner
19257    }
19258}
19259#[repr(C)]
19260#[cfg_attr(feature = "debug", derive(Debug))]
19261#[derive(Copy, Clone)]
19262#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>"]
19263pub struct DisplayNativeHdrSurfaceCapabilitiesAMD {
19264    pub s_type: StructureType,
19265    pub p_next: *mut c_void,
19266    pub local_dimming_support: Bool32,
19267}
19268impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD {
19269    fn default() -> Self {
19270        Self {
19271            s_type: StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
19272            p_next: ::std::ptr::null_mut(),
19273            local_dimming_support: Bool32::default(),
19274        }
19275    }
19276}
19277impl DisplayNativeHdrSurfaceCapabilitiesAMD {
19278    pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19279        DisplayNativeHdrSurfaceCapabilitiesAMDBuilder {
19280            inner: Self::default(),
19281            marker: ::std::marker::PhantomData,
19282        }
19283    }
19284}
19285#[repr(transparent)]
19286pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19287    inner: DisplayNativeHdrSurfaceCapabilitiesAMD,
19288    marker: ::std::marker::PhantomData<&'a ()>,
19289}
19290unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {}
19291unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {}
19292impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19293    type Target = DisplayNativeHdrSurfaceCapabilitiesAMD;
19294    fn deref(&self) -> &Self::Target {
19295        &self.inner
19296    }
19297}
19298impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19299    fn deref_mut(&mut self) -> &mut Self::Target {
19300        &mut self.inner
19301    }
19302}
19303impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
19304    pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self {
19305        self.inner.local_dimming_support = local_dimming_support.into();
19306        self
19307    }
19308    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19309    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19310    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19311    pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD {
19312        self.inner
19313    }
19314}
19315#[repr(C)]
19316#[cfg_attr(feature = "debug", derive(Debug))]
19317#[derive(Copy, Clone)]
19318#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>"]
19319pub struct SwapchainDisplayNativeHdrCreateInfoAMD {
19320    pub s_type: StructureType,
19321    pub p_next: *const c_void,
19322    pub local_dimming_enable: Bool32,
19323}
19324impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD {
19325    fn default() -> Self {
19326        Self {
19327            s_type: StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
19328            p_next: ::std::ptr::null(),
19329            local_dimming_enable: Bool32::default(),
19330        }
19331    }
19332}
19333impl SwapchainDisplayNativeHdrCreateInfoAMD {
19334    pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19335        SwapchainDisplayNativeHdrCreateInfoAMDBuilder {
19336            inner: Self::default(),
19337            marker: ::std::marker::PhantomData,
19338        }
19339    }
19340}
19341#[repr(transparent)]
19342pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19343    inner: SwapchainDisplayNativeHdrCreateInfoAMD,
19344    marker: ::std::marker::PhantomData<&'a ()>,
19345}
19346unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {}
19347unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {}
19348impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19349    type Target = SwapchainDisplayNativeHdrCreateInfoAMD;
19350    fn deref(&self) -> &Self::Target {
19351        &self.inner
19352    }
19353}
19354impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19355    fn deref_mut(&mut self) -> &mut Self::Target {
19356        &mut self.inner
19357    }
19358}
19359impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
19360    pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self {
19361        self.inner.local_dimming_enable = local_dimming_enable.into();
19362        self
19363    }
19364    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19365    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19366    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19367    pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD {
19368        self.inner
19369    }
19370}
19371#[repr(C)]
19372#[cfg_attr(feature = "debug", derive(Debug))]
19373#[derive(Copy, Clone, Default)]
19374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshCycleDurationGOOGLE.html>"]
19375pub struct RefreshCycleDurationGOOGLE {
19376    pub refresh_duration: u64,
19377}
19378impl RefreshCycleDurationGOOGLE {
19379    pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> {
19380        RefreshCycleDurationGOOGLEBuilder {
19381            inner: Self::default(),
19382            marker: ::std::marker::PhantomData,
19383        }
19384    }
19385}
19386#[repr(transparent)]
19387pub struct RefreshCycleDurationGOOGLEBuilder<'a> {
19388    inner: RefreshCycleDurationGOOGLE,
19389    marker: ::std::marker::PhantomData<&'a ()>,
19390}
19391impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> {
19392    type Target = RefreshCycleDurationGOOGLE;
19393    fn deref(&self) -> &Self::Target {
19394        &self.inner
19395    }
19396}
19397impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> {
19398    fn deref_mut(&mut self) -> &mut Self::Target {
19399        &mut self.inner
19400    }
19401}
19402impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> {
19403    pub fn refresh_duration(mut self, refresh_duration: u64) -> Self {
19404        self.inner.refresh_duration = refresh_duration;
19405        self
19406    }
19407    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19408    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19409    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19410    pub fn build(self) -> RefreshCycleDurationGOOGLE {
19411        self.inner
19412    }
19413}
19414#[repr(C)]
19415#[cfg_attr(feature = "debug", derive(Debug))]
19416#[derive(Copy, Clone, Default)]
19417#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPastPresentationTimingGOOGLE.html>"]
19418pub struct PastPresentationTimingGOOGLE {
19419    pub present_id: u32,
19420    pub desired_present_time: u64,
19421    pub actual_present_time: u64,
19422    pub earliest_present_time: u64,
19423    pub present_margin: u64,
19424}
19425impl PastPresentationTimingGOOGLE {
19426    pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> {
19427        PastPresentationTimingGOOGLEBuilder {
19428            inner: Self::default(),
19429            marker: ::std::marker::PhantomData,
19430        }
19431    }
19432}
19433#[repr(transparent)]
19434pub struct PastPresentationTimingGOOGLEBuilder<'a> {
19435    inner: PastPresentationTimingGOOGLE,
19436    marker: ::std::marker::PhantomData<&'a ()>,
19437}
19438impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> {
19439    type Target = PastPresentationTimingGOOGLE;
19440    fn deref(&self) -> &Self::Target {
19441        &self.inner
19442    }
19443}
19444impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> {
19445    fn deref_mut(&mut self) -> &mut Self::Target {
19446        &mut self.inner
19447    }
19448}
19449impl<'a> PastPresentationTimingGOOGLEBuilder<'a> {
19450    pub fn present_id(mut self, present_id: u32) -> Self {
19451        self.inner.present_id = present_id;
19452        self
19453    }
19454    pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
19455        self.inner.desired_present_time = desired_present_time;
19456        self
19457    }
19458    pub fn actual_present_time(mut self, actual_present_time: u64) -> Self {
19459        self.inner.actual_present_time = actual_present_time;
19460        self
19461    }
19462    pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self {
19463        self.inner.earliest_present_time = earliest_present_time;
19464        self
19465    }
19466    pub fn present_margin(mut self, present_margin: u64) -> Self {
19467        self.inner.present_margin = present_margin;
19468        self
19469    }
19470    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19471    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19472    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19473    pub fn build(self) -> PastPresentationTimingGOOGLE {
19474        self.inner
19475    }
19476}
19477#[repr(C)]
19478#[cfg_attr(feature = "debug", derive(Debug))]
19479#[derive(Copy, Clone)]
19480#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimesInfoGOOGLE.html>"]
19481pub struct PresentTimesInfoGOOGLE {
19482    pub s_type: StructureType,
19483    pub p_next: *const c_void,
19484    pub swapchain_count: u32,
19485    pub p_times: *const PresentTimeGOOGLE,
19486}
19487impl ::std::default::Default for PresentTimesInfoGOOGLE {
19488    fn default() -> Self {
19489        Self {
19490            s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE,
19491            p_next: ::std::ptr::null(),
19492            swapchain_count: u32::default(),
19493            p_times: ::std::ptr::null(),
19494        }
19495    }
19496}
19497impl PresentTimesInfoGOOGLE {
19498    pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> {
19499        PresentTimesInfoGOOGLEBuilder {
19500            inner: Self::default(),
19501            marker: ::std::marker::PhantomData,
19502        }
19503    }
19504}
19505#[repr(transparent)]
19506pub struct PresentTimesInfoGOOGLEBuilder<'a> {
19507    inner: PresentTimesInfoGOOGLE,
19508    marker: ::std::marker::PhantomData<&'a ()>,
19509}
19510unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {}
19511unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {}
19512impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> {
19513    type Target = PresentTimesInfoGOOGLE;
19514    fn deref(&self) -> &Self::Target {
19515        &self.inner
19516    }
19517}
19518impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> {
19519    fn deref_mut(&mut self) -> &mut Self::Target {
19520        &mut self.inner
19521    }
19522}
19523impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
19524    pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self {
19525        self.inner.swapchain_count = times.len() as _;
19526        self.inner.p_times = times.as_ptr();
19527        self
19528    }
19529    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19530    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19531    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19532    pub fn build(self) -> PresentTimesInfoGOOGLE {
19533        self.inner
19534    }
19535}
19536#[repr(C)]
19537#[cfg_attr(feature = "debug", derive(Debug))]
19538#[derive(Copy, Clone, Default)]
19539#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimeGOOGLE.html>"]
19540pub struct PresentTimeGOOGLE {
19541    pub present_id: u32,
19542    pub desired_present_time: u64,
19543}
19544impl PresentTimeGOOGLE {
19545    pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> {
19546        PresentTimeGOOGLEBuilder {
19547            inner: Self::default(),
19548            marker: ::std::marker::PhantomData,
19549        }
19550    }
19551}
19552#[repr(transparent)]
19553pub struct PresentTimeGOOGLEBuilder<'a> {
19554    inner: PresentTimeGOOGLE,
19555    marker: ::std::marker::PhantomData<&'a ()>,
19556}
19557impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> {
19558    type Target = PresentTimeGOOGLE;
19559    fn deref(&self) -> &Self::Target {
19560        &self.inner
19561    }
19562}
19563impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> {
19564    fn deref_mut(&mut self) -> &mut Self::Target {
19565        &mut self.inner
19566    }
19567}
19568impl<'a> PresentTimeGOOGLEBuilder<'a> {
19569    pub fn present_id(mut self, present_id: u32) -> Self {
19570        self.inner.present_id = present_id;
19571        self
19572    }
19573    pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
19574        self.inner.desired_present_time = desired_present_time;
19575        self
19576    }
19577    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19578    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19579    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19580    pub fn build(self) -> PresentTimeGOOGLE {
19581        self.inner
19582    }
19583}
19584#[repr(C)]
19585#[cfg_attr(feature = "debug", derive(Debug))]
19586#[derive(Copy, Clone)]
19587#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateInfoMVK.html>"]
19588pub struct IOSSurfaceCreateInfoMVK {
19589    pub s_type: StructureType,
19590    pub p_next: *const c_void,
19591    pub flags: IOSSurfaceCreateFlagsMVK,
19592    pub p_view: *const c_void,
19593}
19594impl ::std::default::Default for IOSSurfaceCreateInfoMVK {
19595    fn default() -> Self {
19596        Self {
19597            s_type: StructureType::IOS_SURFACE_CREATE_INFO_MVK,
19598            p_next: ::std::ptr::null(),
19599            flags: IOSSurfaceCreateFlagsMVK::default(),
19600            p_view: ::std::ptr::null(),
19601        }
19602    }
19603}
19604impl IOSSurfaceCreateInfoMVK {
19605    pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> {
19606        IOSSurfaceCreateInfoMVKBuilder {
19607            inner: Self::default(),
19608            marker: ::std::marker::PhantomData,
19609        }
19610    }
19611}
19612#[repr(transparent)]
19613pub struct IOSSurfaceCreateInfoMVKBuilder<'a> {
19614    inner: IOSSurfaceCreateInfoMVK,
19615    marker: ::std::marker::PhantomData<&'a ()>,
19616}
19617impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> {
19618    type Target = IOSSurfaceCreateInfoMVK;
19619    fn deref(&self) -> &Self::Target {
19620        &self.inner
19621    }
19622}
19623impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> {
19624    fn deref_mut(&mut self) -> &mut Self::Target {
19625        &mut self.inner
19626    }
19627}
19628impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
19629    pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self {
19630        self.inner.flags = flags;
19631        self
19632    }
19633    pub fn view(mut self, view: *const c_void) -> Self {
19634        self.inner.p_view = view;
19635        self
19636    }
19637    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19638    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19639    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19640    pub fn build(self) -> IOSSurfaceCreateInfoMVK {
19641        self.inner
19642    }
19643}
19644#[repr(C)]
19645#[cfg_attr(feature = "debug", derive(Debug))]
19646#[derive(Copy, Clone)]
19647#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html>"]
19648pub struct MacOSSurfaceCreateInfoMVK {
19649    pub s_type: StructureType,
19650    pub p_next: *const c_void,
19651    pub flags: MacOSSurfaceCreateFlagsMVK,
19652    pub p_view: *const c_void,
19653}
19654impl ::std::default::Default for MacOSSurfaceCreateInfoMVK {
19655    fn default() -> Self {
19656        Self {
19657            s_type: StructureType::MACOS_SURFACE_CREATE_INFO_MVK,
19658            p_next: ::std::ptr::null(),
19659            flags: MacOSSurfaceCreateFlagsMVK::default(),
19660            p_view: ::std::ptr::null(),
19661        }
19662    }
19663}
19664impl MacOSSurfaceCreateInfoMVK {
19665    pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
19666        MacOSSurfaceCreateInfoMVKBuilder {
19667            inner: Self::default(),
19668            marker: ::std::marker::PhantomData,
19669        }
19670    }
19671}
19672#[repr(transparent)]
19673pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> {
19674    inner: MacOSSurfaceCreateInfoMVK,
19675    marker: ::std::marker::PhantomData<&'a ()>,
19676}
19677impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> {
19678    type Target = MacOSSurfaceCreateInfoMVK;
19679    fn deref(&self) -> &Self::Target {
19680        &self.inner
19681    }
19682}
19683impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> {
19684    fn deref_mut(&mut self) -> &mut Self::Target {
19685        &mut self.inner
19686    }
19687}
19688impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
19689    pub fn flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self {
19690        self.inner.flags = flags;
19691        self
19692    }
19693    pub fn view(mut self, view: *const c_void) -> Self {
19694        self.inner.p_view = view;
19695        self
19696    }
19697    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19698    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19699    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19700    pub fn build(self) -> MacOSSurfaceCreateInfoMVK {
19701        self.inner
19702    }
19703}
19704#[repr(C)]
19705#[cfg_attr(feature = "debug", derive(Debug))]
19706#[derive(Copy, Clone)]
19707#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html>"]
19708pub struct MetalSurfaceCreateInfoEXT {
19709    pub s_type: StructureType,
19710    pub p_next: *const c_void,
19711    pub flags: MetalSurfaceCreateFlagsEXT,
19712    pub p_layer: *const CAMetalLayer,
19713}
19714impl ::std::default::Default for MetalSurfaceCreateInfoEXT {
19715    fn default() -> Self {
19716        Self {
19717            s_type: StructureType::METAL_SURFACE_CREATE_INFO_EXT,
19718            p_next: ::std::ptr::null(),
19719            flags: MetalSurfaceCreateFlagsEXT::default(),
19720            p_layer: ::std::ptr::null(),
19721        }
19722    }
19723}
19724impl MetalSurfaceCreateInfoEXT {
19725    pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> {
19726        MetalSurfaceCreateInfoEXTBuilder {
19727            inner: Self::default(),
19728            marker: ::std::marker::PhantomData,
19729        }
19730    }
19731}
19732#[repr(transparent)]
19733pub struct MetalSurfaceCreateInfoEXTBuilder<'a> {
19734    inner: MetalSurfaceCreateInfoEXT,
19735    marker: ::std::marker::PhantomData<&'a ()>,
19736}
19737impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> {
19738    type Target = MetalSurfaceCreateInfoEXT;
19739    fn deref(&self) -> &Self::Target {
19740        &self.inner
19741    }
19742}
19743impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> {
19744    fn deref_mut(&mut self) -> &mut Self::Target {
19745        &mut self.inner
19746    }
19747}
19748impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
19749    pub fn flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self {
19750        self.inner.flags = flags;
19751        self
19752    }
19753    pub fn layer(mut self, layer: *const CAMetalLayer) -> Self {
19754        self.inner.p_layer = layer;
19755        self
19756    }
19757    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19758    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19759    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19760    pub fn build(self) -> MetalSurfaceCreateInfoEXT {
19761        self.inner
19762    }
19763}
19764#[repr(C)]
19765#[cfg_attr(feature = "debug", derive(Debug))]
19766#[derive(Copy, Clone, Default)]
19767#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportWScalingNV.html>"]
19768pub struct ViewportWScalingNV {
19769    pub xcoeff: f32,
19770    pub ycoeff: f32,
19771}
19772impl ViewportWScalingNV {
19773    pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> {
19774        ViewportWScalingNVBuilder {
19775            inner: Self::default(),
19776            marker: ::std::marker::PhantomData,
19777        }
19778    }
19779}
19780#[repr(transparent)]
19781pub struct ViewportWScalingNVBuilder<'a> {
19782    inner: ViewportWScalingNV,
19783    marker: ::std::marker::PhantomData<&'a ()>,
19784}
19785impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> {
19786    type Target = ViewportWScalingNV;
19787    fn deref(&self) -> &Self::Target {
19788        &self.inner
19789    }
19790}
19791impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> {
19792    fn deref_mut(&mut self) -> &mut Self::Target {
19793        &mut self.inner
19794    }
19795}
19796impl<'a> ViewportWScalingNVBuilder<'a> {
19797    pub fn xcoeff(mut self, xcoeff: f32) -> Self {
19798        self.inner.xcoeff = xcoeff;
19799        self
19800    }
19801    pub fn ycoeff(mut self, ycoeff: f32) -> Self {
19802        self.inner.ycoeff = ycoeff;
19803        self
19804    }
19805    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19806    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19807    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19808    pub fn build(self) -> ViewportWScalingNV {
19809        self.inner
19810    }
19811}
19812#[repr(C)]
19813#[cfg_attr(feature = "debug", derive(Debug))]
19814#[derive(Copy, Clone)]
19815#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>"]
19816pub struct PipelineViewportWScalingStateCreateInfoNV {
19817    pub s_type: StructureType,
19818    pub p_next: *const c_void,
19819    pub viewport_w_scaling_enable: Bool32,
19820    pub viewport_count: u32,
19821    pub p_viewport_w_scalings: *const ViewportWScalingNV,
19822}
19823impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV {
19824    fn default() -> Self {
19825        Self {
19826            s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
19827            p_next: ::std::ptr::null(),
19828            viewport_w_scaling_enable: Bool32::default(),
19829            viewport_count: u32::default(),
19830            p_viewport_w_scalings: ::std::ptr::null(),
19831        }
19832    }
19833}
19834impl PipelineViewportWScalingStateCreateInfoNV {
19835    pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19836        PipelineViewportWScalingStateCreateInfoNVBuilder {
19837            inner: Self::default(),
19838            marker: ::std::marker::PhantomData,
19839        }
19840    }
19841}
19842#[repr(transparent)]
19843pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19844    inner: PipelineViewportWScalingStateCreateInfoNV,
19845    marker: ::std::marker::PhantomData<&'a ()>,
19846}
19847unsafe impl ExtendsPipelineViewportStateCreateInfo
19848    for PipelineViewportWScalingStateCreateInfoNVBuilder<'_>
19849{
19850}
19851unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {}
19852impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19853    type Target = PipelineViewportWScalingStateCreateInfoNV;
19854    fn deref(&self) -> &Self::Target {
19855        &self.inner
19856    }
19857}
19858impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19859    fn deref_mut(&mut self) -> &mut Self::Target {
19860        &mut self.inner
19861    }
19862}
19863impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
19864    pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self {
19865        self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into();
19866        self
19867    }
19868    pub fn viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self {
19869        self.inner.viewport_count = viewport_w_scalings.len() as _;
19870        self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr();
19871        self
19872    }
19873    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19874    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19875    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19876    pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV {
19877        self.inner
19878    }
19879}
19880#[repr(C)]
19881#[cfg_attr(feature = "debug", derive(Debug))]
19882#[derive(Copy, Clone, Default)]
19883#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportSwizzleNV.html>"]
19884pub struct ViewportSwizzleNV {
19885    pub x: ViewportCoordinateSwizzleNV,
19886    pub y: ViewportCoordinateSwizzleNV,
19887    pub z: ViewportCoordinateSwizzleNV,
19888    pub w: ViewportCoordinateSwizzleNV,
19889}
19890impl ViewportSwizzleNV {
19891    pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> {
19892        ViewportSwizzleNVBuilder {
19893            inner: Self::default(),
19894            marker: ::std::marker::PhantomData,
19895        }
19896    }
19897}
19898#[repr(transparent)]
19899pub struct ViewportSwizzleNVBuilder<'a> {
19900    inner: ViewportSwizzleNV,
19901    marker: ::std::marker::PhantomData<&'a ()>,
19902}
19903impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> {
19904    type Target = ViewportSwizzleNV;
19905    fn deref(&self) -> &Self::Target {
19906        &self.inner
19907    }
19908}
19909impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> {
19910    fn deref_mut(&mut self) -> &mut Self::Target {
19911        &mut self.inner
19912    }
19913}
19914impl<'a> ViewportSwizzleNVBuilder<'a> {
19915    pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> Self {
19916        self.inner.x = x;
19917        self
19918    }
19919    pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> Self {
19920        self.inner.y = y;
19921        self
19922    }
19923    pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> Self {
19924        self.inner.z = z;
19925        self
19926    }
19927    pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> Self {
19928        self.inner.w = w;
19929        self
19930    }
19931    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19932    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19933    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
19934    pub fn build(self) -> ViewportSwizzleNV {
19935        self.inner
19936    }
19937}
19938#[repr(C)]
19939#[cfg_attr(feature = "debug", derive(Debug))]
19940#[derive(Copy, Clone)]
19941#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>"]
19942pub struct PipelineViewportSwizzleStateCreateInfoNV {
19943    pub s_type: StructureType,
19944    pub p_next: *const c_void,
19945    pub flags: PipelineViewportSwizzleStateCreateFlagsNV,
19946    pub viewport_count: u32,
19947    pub p_viewport_swizzles: *const ViewportSwizzleNV,
19948}
19949impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV {
19950    fn default() -> Self {
19951        Self {
19952            s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
19953            p_next: ::std::ptr::null(),
19954            flags: PipelineViewportSwizzleStateCreateFlagsNV::default(),
19955            viewport_count: u32::default(),
19956            p_viewport_swizzles: ::std::ptr::null(),
19957        }
19958    }
19959}
19960impl PipelineViewportSwizzleStateCreateInfoNV {
19961    pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19962        PipelineViewportSwizzleStateCreateInfoNVBuilder {
19963            inner: Self::default(),
19964            marker: ::std::marker::PhantomData,
19965        }
19966    }
19967}
19968#[repr(transparent)]
19969pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19970    inner: PipelineViewportSwizzleStateCreateInfoNV,
19971    marker: ::std::marker::PhantomData<&'a ()>,
19972}
19973unsafe impl ExtendsPipelineViewportStateCreateInfo
19974    for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_>
19975{
19976}
19977unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {}
19978impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19979    type Target = PipelineViewportSwizzleStateCreateInfoNV;
19980    fn deref(&self) -> &Self::Target {
19981        &self.inner
19982    }
19983}
19984impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19985    fn deref_mut(&mut self) -> &mut Self::Target {
19986        &mut self.inner
19987    }
19988}
19989impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
19990    pub fn flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self {
19991        self.inner.flags = flags;
19992        self
19993    }
19994    pub fn viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self {
19995        self.inner.viewport_count = viewport_swizzles.len() as _;
19996        self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr();
19997        self
19998    }
19999    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20000    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20001    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20002    pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV {
20003        self.inner
20004    }
20005}
20006#[repr(C)]
20007#[cfg_attr(feature = "debug", derive(Debug))]
20008#[derive(Copy, Clone)]
20009#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>"]
20010pub struct PhysicalDeviceDiscardRectanglePropertiesEXT {
20011    pub s_type: StructureType,
20012    pub p_next: *mut c_void,
20013    pub max_discard_rectangles: u32,
20014}
20015impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT {
20016    fn default() -> Self {
20017        Self {
20018            s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
20019            p_next: ::std::ptr::null_mut(),
20020            max_discard_rectangles: u32::default(),
20021        }
20022    }
20023}
20024impl PhysicalDeviceDiscardRectanglePropertiesEXT {
20025    pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20026        PhysicalDeviceDiscardRectanglePropertiesEXTBuilder {
20027            inner: Self::default(),
20028            marker: ::std::marker::PhantomData,
20029        }
20030    }
20031}
20032#[repr(transparent)]
20033pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20034    inner: PhysicalDeviceDiscardRectanglePropertiesEXT,
20035    marker: ::std::marker::PhantomData<&'a ()>,
20036}
20037unsafe impl ExtendsPhysicalDeviceProperties2
20038    for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_>
20039{
20040}
20041unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {}
20042impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20043    type Target = PhysicalDeviceDiscardRectanglePropertiesEXT;
20044    fn deref(&self) -> &Self::Target {
20045        &self.inner
20046    }
20047}
20048impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20049    fn deref_mut(&mut self) -> &mut Self::Target {
20050        &mut self.inner
20051    }
20052}
20053impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
20054    pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self {
20055        self.inner.max_discard_rectangles = max_discard_rectangles;
20056        self
20057    }
20058    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20059    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20060    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20061    pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT {
20062        self.inner
20063    }
20064}
20065#[repr(C)]
20066#[cfg_attr(feature = "debug", derive(Debug))]
20067#[derive(Copy, Clone)]
20068#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>"]
20069pub struct PipelineDiscardRectangleStateCreateInfoEXT {
20070    pub s_type: StructureType,
20071    pub p_next: *const c_void,
20072    pub flags: PipelineDiscardRectangleStateCreateFlagsEXT,
20073    pub discard_rectangle_mode: DiscardRectangleModeEXT,
20074    pub discard_rectangle_count: u32,
20075    pub p_discard_rectangles: *const Rect2D,
20076}
20077impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT {
20078    fn default() -> Self {
20079        Self {
20080            s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
20081            p_next: ::std::ptr::null(),
20082            flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(),
20083            discard_rectangle_mode: DiscardRectangleModeEXT::default(),
20084            discard_rectangle_count: u32::default(),
20085            p_discard_rectangles: ::std::ptr::null(),
20086        }
20087    }
20088}
20089impl PipelineDiscardRectangleStateCreateInfoEXT {
20090    pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20091        PipelineDiscardRectangleStateCreateInfoEXTBuilder {
20092            inner: Self::default(),
20093            marker: ::std::marker::PhantomData,
20094        }
20095    }
20096}
20097#[repr(transparent)]
20098pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20099    inner: PipelineDiscardRectangleStateCreateInfoEXT,
20100    marker: ::std::marker::PhantomData<&'a ()>,
20101}
20102unsafe impl ExtendsGraphicsPipelineCreateInfo
20103    for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_>
20104{
20105}
20106unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {}
20107impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20108    type Target = PipelineDiscardRectangleStateCreateInfoEXT;
20109    fn deref(&self) -> &Self::Target {
20110        &self.inner
20111    }
20112}
20113impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20114    fn deref_mut(&mut self) -> &mut Self::Target {
20115        &mut self.inner
20116    }
20117}
20118impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
20119    pub fn flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self {
20120        self.inner.flags = flags;
20121        self
20122    }
20123    pub fn discard_rectangle_mode(
20124        mut self,
20125        discard_rectangle_mode: DiscardRectangleModeEXT,
20126    ) -> Self {
20127        self.inner.discard_rectangle_mode = discard_rectangle_mode;
20128        self
20129    }
20130    pub fn discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self {
20131        self.inner.discard_rectangle_count = discard_rectangles.len() as _;
20132        self.inner.p_discard_rectangles = discard_rectangles.as_ptr();
20133        self
20134    }
20135    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20136    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20137    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20138    pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT {
20139        self.inner
20140    }
20141}
20142#[repr(C)]
20143#[cfg_attr(feature = "debug", derive(Debug))]
20144#[derive(Copy, Clone)]
20145#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>"]
20146pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20147    pub s_type: StructureType,
20148    pub p_next: *mut c_void,
20149    pub per_view_position_all_components: Bool32,
20150}
20151impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20152    fn default() -> Self {
20153        Self {
20154            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
20155            p_next: ::std::ptr::null_mut(),
20156            per_view_position_all_components: Bool32::default(),
20157        }
20158    }
20159}
20160impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20161    pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20162        PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder {
20163            inner: Self::default(),
20164            marker: ::std::marker::PhantomData,
20165        }
20166    }
20167}
20168#[repr(transparent)]
20169pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20170    inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
20171    marker: ::std::marker::PhantomData<&'a ()>,
20172}
20173unsafe impl ExtendsPhysicalDeviceProperties2
20174    for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_>
20175{
20176}
20177unsafe impl ExtendsPhysicalDeviceProperties2
20178    for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
20179{
20180}
20181impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20182    type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
20183    fn deref(&self) -> &Self::Target {
20184        &self.inner
20185    }
20186}
20187impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20188    fn deref_mut(&mut self) -> &mut Self::Target {
20189        &mut self.inner
20190    }
20191}
20192impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
20193    pub fn per_view_position_all_components(
20194        mut self,
20195        per_view_position_all_components: bool,
20196    ) -> Self {
20197        self.inner.per_view_position_all_components = per_view_position_all_components.into();
20198        self
20199    }
20200    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20201    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20202    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20203    pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
20204        self.inner
20205    }
20206}
20207#[repr(C)]
20208#[cfg_attr(feature = "debug", derive(Debug))]
20209#[derive(Copy, Clone, Default)]
20210#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInputAttachmentAspectReference.html>"]
20211pub struct InputAttachmentAspectReference {
20212    pub subpass: u32,
20213    pub input_attachment_index: u32,
20214    pub aspect_mask: ImageAspectFlags,
20215}
20216impl InputAttachmentAspectReference {
20217    pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> {
20218        InputAttachmentAspectReferenceBuilder {
20219            inner: Self::default(),
20220            marker: ::std::marker::PhantomData,
20221        }
20222    }
20223}
20224#[repr(transparent)]
20225pub struct InputAttachmentAspectReferenceBuilder<'a> {
20226    inner: InputAttachmentAspectReference,
20227    marker: ::std::marker::PhantomData<&'a ()>,
20228}
20229impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> {
20230    type Target = InputAttachmentAspectReference;
20231    fn deref(&self) -> &Self::Target {
20232        &self.inner
20233    }
20234}
20235impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> {
20236    fn deref_mut(&mut self) -> &mut Self::Target {
20237        &mut self.inner
20238    }
20239}
20240impl<'a> InputAttachmentAspectReferenceBuilder<'a> {
20241    pub fn subpass(mut self, subpass: u32) -> Self {
20242        self.inner.subpass = subpass;
20243        self
20244    }
20245    pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self {
20246        self.inner.input_attachment_index = input_attachment_index;
20247        self
20248    }
20249    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
20250        self.inner.aspect_mask = aspect_mask;
20251        self
20252    }
20253    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20254    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20255    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20256    pub fn build(self) -> InputAttachmentAspectReference {
20257        self.inner
20258    }
20259}
20260#[repr(C)]
20261#[cfg_attr(feature = "debug", derive(Debug))]
20262#[derive(Copy, Clone)]
20263#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>"]
20264pub struct RenderPassInputAttachmentAspectCreateInfo {
20265    pub s_type: StructureType,
20266    pub p_next: *const c_void,
20267    pub aspect_reference_count: u32,
20268    pub p_aspect_references: *const InputAttachmentAspectReference,
20269}
20270impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo {
20271    fn default() -> Self {
20272        Self {
20273            s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
20274            p_next: ::std::ptr::null(),
20275            aspect_reference_count: u32::default(),
20276            p_aspect_references: ::std::ptr::null(),
20277        }
20278    }
20279}
20280impl RenderPassInputAttachmentAspectCreateInfo {
20281    pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20282        RenderPassInputAttachmentAspectCreateInfoBuilder {
20283            inner: Self::default(),
20284            marker: ::std::marker::PhantomData,
20285        }
20286    }
20287}
20288#[repr(transparent)]
20289pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20290    inner: RenderPassInputAttachmentAspectCreateInfo,
20291    marker: ::std::marker::PhantomData<&'a ()>,
20292}
20293unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {}
20294unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {}
20295impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20296    type Target = RenderPassInputAttachmentAspectCreateInfo;
20297    fn deref(&self) -> &Self::Target {
20298        &self.inner
20299    }
20300}
20301impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20302    fn deref_mut(&mut self) -> &mut Self::Target {
20303        &mut self.inner
20304    }
20305}
20306impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
20307    pub fn aspect_references(
20308        mut self,
20309        aspect_references: &'a [InputAttachmentAspectReference],
20310    ) -> Self {
20311        self.inner.aspect_reference_count = aspect_references.len() as _;
20312        self.inner.p_aspect_references = aspect_references.as_ptr();
20313        self
20314    }
20315    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20316    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20317    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20318    pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo {
20319        self.inner
20320    }
20321}
20322#[repr(C)]
20323#[cfg_attr(feature = "debug", derive(Debug))]
20324#[derive(Copy, Clone)]
20325#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>"]
20326pub struct PhysicalDeviceSurfaceInfo2KHR {
20327    pub s_type: StructureType,
20328    pub p_next: *const c_void,
20329    pub surface: SurfaceKHR,
20330}
20331impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR {
20332    fn default() -> Self {
20333        Self {
20334            s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
20335            p_next: ::std::ptr::null(),
20336            surface: SurfaceKHR::default(),
20337        }
20338    }
20339}
20340impl PhysicalDeviceSurfaceInfo2KHR {
20341    pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20342        PhysicalDeviceSurfaceInfo2KHRBuilder {
20343            inner: Self::default(),
20344            marker: ::std::marker::PhantomData,
20345        }
20346    }
20347}
20348#[repr(transparent)]
20349pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20350    inner: PhysicalDeviceSurfaceInfo2KHR,
20351    marker: ::std::marker::PhantomData<&'a ()>,
20352}
20353pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {}
20354impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20355    type Target = PhysicalDeviceSurfaceInfo2KHR;
20356    fn deref(&self) -> &Self::Target {
20357        &self.inner
20358    }
20359}
20360impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20361    fn deref_mut(&mut self) -> &mut Self::Target {
20362        &mut self.inner
20363    }
20364}
20365impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
20366    pub fn surface(mut self, surface: SurfaceKHR) -> Self {
20367        self.inner.surface = surface;
20368        self
20369    }
20370    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20371    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20372    #[doc = r" valid extension structs can be pushed into the chain."]
20373    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20374    #[doc = r" chain will look like `A -> D -> B -> C`."]
20375    pub fn push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(mut self, next: &'a mut T) -> Self {
20376        unsafe {
20377            let next_ptr = <*const T>::cast(next);
20378            let last_next = ptr_chain_iter(next).last().unwrap();
20379            (*last_next).p_next = self.inner.p_next as _;
20380            self.inner.p_next = next_ptr;
20381        }
20382        self
20383    }
20384    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20385    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20386    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20387    pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR {
20388        self.inner
20389    }
20390}
20391#[repr(C)]
20392#[cfg_attr(feature = "debug", derive(Debug))]
20393#[derive(Copy, Clone)]
20394#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2KHR.html>"]
20395pub struct SurfaceCapabilities2KHR {
20396    pub s_type: StructureType,
20397    pub p_next: *mut c_void,
20398    pub surface_capabilities: SurfaceCapabilitiesKHR,
20399}
20400impl ::std::default::Default for SurfaceCapabilities2KHR {
20401    fn default() -> Self {
20402        Self {
20403            s_type: StructureType::SURFACE_CAPABILITIES_2_KHR,
20404            p_next: ::std::ptr::null_mut(),
20405            surface_capabilities: SurfaceCapabilitiesKHR::default(),
20406        }
20407    }
20408}
20409impl SurfaceCapabilities2KHR {
20410    pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> {
20411        SurfaceCapabilities2KHRBuilder {
20412            inner: Self::default(),
20413            marker: ::std::marker::PhantomData,
20414        }
20415    }
20416}
20417#[repr(transparent)]
20418pub struct SurfaceCapabilities2KHRBuilder<'a> {
20419    inner: SurfaceCapabilities2KHR,
20420    marker: ::std::marker::PhantomData<&'a ()>,
20421}
20422pub unsafe trait ExtendsSurfaceCapabilities2KHR {}
20423impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> {
20424    type Target = SurfaceCapabilities2KHR;
20425    fn deref(&self) -> &Self::Target {
20426        &self.inner
20427    }
20428}
20429impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> {
20430    fn deref_mut(&mut self) -> &mut Self::Target {
20431        &mut self.inner
20432    }
20433}
20434impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
20435    pub fn surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self {
20436        self.inner.surface_capabilities = surface_capabilities;
20437        self
20438    }
20439    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20440    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20441    #[doc = r" valid extension structs can be pushed into the chain."]
20442    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20443    #[doc = r" chain will look like `A -> D -> B -> C`."]
20444    pub fn push_next<T: ExtendsSurfaceCapabilities2KHR>(mut self, next: &'a mut T) -> Self {
20445        unsafe {
20446            let next_ptr = <*mut T>::cast(next);
20447            let last_next = ptr_chain_iter(next).last().unwrap();
20448            (*last_next).p_next = self.inner.p_next as _;
20449            self.inner.p_next = next_ptr;
20450        }
20451        self
20452    }
20453    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20454    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20455    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20456    pub fn build(self) -> SurfaceCapabilities2KHR {
20457        self.inner
20458    }
20459}
20460#[repr(C)]
20461#[cfg_attr(feature = "debug", derive(Debug))]
20462#[derive(Copy, Clone)]
20463#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormat2KHR.html>"]
20464pub struct SurfaceFormat2KHR {
20465    pub s_type: StructureType,
20466    pub p_next: *mut c_void,
20467    pub surface_format: SurfaceFormatKHR,
20468}
20469impl ::std::default::Default for SurfaceFormat2KHR {
20470    fn default() -> Self {
20471        Self {
20472            s_type: StructureType::SURFACE_FORMAT_2_KHR,
20473            p_next: ::std::ptr::null_mut(),
20474            surface_format: SurfaceFormatKHR::default(),
20475        }
20476    }
20477}
20478impl SurfaceFormat2KHR {
20479    pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> {
20480        SurfaceFormat2KHRBuilder {
20481            inner: Self::default(),
20482            marker: ::std::marker::PhantomData,
20483        }
20484    }
20485}
20486#[repr(transparent)]
20487pub struct SurfaceFormat2KHRBuilder<'a> {
20488    inner: SurfaceFormat2KHR,
20489    marker: ::std::marker::PhantomData<&'a ()>,
20490}
20491impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> {
20492    type Target = SurfaceFormat2KHR;
20493    fn deref(&self) -> &Self::Target {
20494        &self.inner
20495    }
20496}
20497impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> {
20498    fn deref_mut(&mut self) -> &mut Self::Target {
20499        &mut self.inner
20500    }
20501}
20502impl<'a> SurfaceFormat2KHRBuilder<'a> {
20503    pub fn surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self {
20504        self.inner.surface_format = surface_format;
20505        self
20506    }
20507    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20508    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20509    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20510    pub fn build(self) -> SurfaceFormat2KHR {
20511        self.inner
20512    }
20513}
20514#[repr(C)]
20515#[cfg_attr(feature = "debug", derive(Debug))]
20516#[derive(Copy, Clone)]
20517#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayProperties2KHR.html>"]
20518pub struct DisplayProperties2KHR {
20519    pub s_type: StructureType,
20520    pub p_next: *mut c_void,
20521    pub display_properties: DisplayPropertiesKHR,
20522}
20523impl ::std::default::Default for DisplayProperties2KHR {
20524    fn default() -> Self {
20525        Self {
20526            s_type: StructureType::DISPLAY_PROPERTIES_2_KHR,
20527            p_next: ::std::ptr::null_mut(),
20528            display_properties: DisplayPropertiesKHR::default(),
20529        }
20530    }
20531}
20532impl DisplayProperties2KHR {
20533    pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> {
20534        DisplayProperties2KHRBuilder {
20535            inner: Self::default(),
20536            marker: ::std::marker::PhantomData,
20537        }
20538    }
20539}
20540#[repr(transparent)]
20541pub struct DisplayProperties2KHRBuilder<'a> {
20542    inner: DisplayProperties2KHR,
20543    marker: ::std::marker::PhantomData<&'a ()>,
20544}
20545impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> {
20546    type Target = DisplayProperties2KHR;
20547    fn deref(&self) -> &Self::Target {
20548        &self.inner
20549    }
20550}
20551impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> {
20552    fn deref_mut(&mut self) -> &mut Self::Target {
20553        &mut self.inner
20554    }
20555}
20556impl<'a> DisplayProperties2KHRBuilder<'a> {
20557    pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self {
20558        self.inner.display_properties = display_properties;
20559        self
20560    }
20561    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20562    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20563    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20564    pub fn build(self) -> DisplayProperties2KHR {
20565        self.inner
20566    }
20567}
20568#[repr(C)]
20569#[cfg_attr(feature = "debug", derive(Debug))]
20570#[derive(Copy, Clone)]
20571#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneProperties2KHR.html>"]
20572pub struct DisplayPlaneProperties2KHR {
20573    pub s_type: StructureType,
20574    pub p_next: *mut c_void,
20575    pub display_plane_properties: DisplayPlanePropertiesKHR,
20576}
20577impl ::std::default::Default for DisplayPlaneProperties2KHR {
20578    fn default() -> Self {
20579        Self {
20580            s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR,
20581            p_next: ::std::ptr::null_mut(),
20582            display_plane_properties: DisplayPlanePropertiesKHR::default(),
20583        }
20584    }
20585}
20586impl DisplayPlaneProperties2KHR {
20587    pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> {
20588        DisplayPlaneProperties2KHRBuilder {
20589            inner: Self::default(),
20590            marker: ::std::marker::PhantomData,
20591        }
20592    }
20593}
20594#[repr(transparent)]
20595pub struct DisplayPlaneProperties2KHRBuilder<'a> {
20596    inner: DisplayPlaneProperties2KHR,
20597    marker: ::std::marker::PhantomData<&'a ()>,
20598}
20599impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> {
20600    type Target = DisplayPlaneProperties2KHR;
20601    fn deref(&self) -> &Self::Target {
20602        &self.inner
20603    }
20604}
20605impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> {
20606    fn deref_mut(&mut self) -> &mut Self::Target {
20607        &mut self.inner
20608    }
20609}
20610impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
20611    pub fn display_plane_properties(
20612        mut self,
20613        display_plane_properties: DisplayPlanePropertiesKHR,
20614    ) -> Self {
20615        self.inner.display_plane_properties = display_plane_properties;
20616        self
20617    }
20618    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20619    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20620    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20621    pub fn build(self) -> DisplayPlaneProperties2KHR {
20622        self.inner
20623    }
20624}
20625#[repr(C)]
20626#[cfg_attr(feature = "debug", derive(Debug))]
20627#[derive(Copy, Clone)]
20628#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeProperties2KHR.html>"]
20629pub struct DisplayModeProperties2KHR {
20630    pub s_type: StructureType,
20631    pub p_next: *mut c_void,
20632    pub display_mode_properties: DisplayModePropertiesKHR,
20633}
20634impl ::std::default::Default for DisplayModeProperties2KHR {
20635    fn default() -> Self {
20636        Self {
20637            s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR,
20638            p_next: ::std::ptr::null_mut(),
20639            display_mode_properties: DisplayModePropertiesKHR::default(),
20640        }
20641    }
20642}
20643impl DisplayModeProperties2KHR {
20644    pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> {
20645        DisplayModeProperties2KHRBuilder {
20646            inner: Self::default(),
20647            marker: ::std::marker::PhantomData,
20648        }
20649    }
20650}
20651#[repr(transparent)]
20652pub struct DisplayModeProperties2KHRBuilder<'a> {
20653    inner: DisplayModeProperties2KHR,
20654    marker: ::std::marker::PhantomData<&'a ()>,
20655}
20656impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> {
20657    type Target = DisplayModeProperties2KHR;
20658    fn deref(&self) -> &Self::Target {
20659        &self.inner
20660    }
20661}
20662impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> {
20663    fn deref_mut(&mut self) -> &mut Self::Target {
20664        &mut self.inner
20665    }
20666}
20667impl<'a> DisplayModeProperties2KHRBuilder<'a> {
20668    pub fn display_mode_properties(
20669        mut self,
20670        display_mode_properties: DisplayModePropertiesKHR,
20671    ) -> Self {
20672        self.inner.display_mode_properties = display_mode_properties;
20673        self
20674    }
20675    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20676    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20677    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20678    pub fn build(self) -> DisplayModeProperties2KHR {
20679        self.inner
20680    }
20681}
20682#[repr(C)]
20683#[cfg_attr(feature = "debug", derive(Debug))]
20684#[derive(Copy, Clone)]
20685#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneInfo2KHR.html>"]
20686pub struct DisplayPlaneInfo2KHR {
20687    pub s_type: StructureType,
20688    pub p_next: *const c_void,
20689    pub mode: DisplayModeKHR,
20690    pub plane_index: u32,
20691}
20692impl ::std::default::Default for DisplayPlaneInfo2KHR {
20693    fn default() -> Self {
20694        Self {
20695            s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR,
20696            p_next: ::std::ptr::null(),
20697            mode: DisplayModeKHR::default(),
20698            plane_index: u32::default(),
20699        }
20700    }
20701}
20702impl DisplayPlaneInfo2KHR {
20703    pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> {
20704        DisplayPlaneInfo2KHRBuilder {
20705            inner: Self::default(),
20706            marker: ::std::marker::PhantomData,
20707        }
20708    }
20709}
20710#[repr(transparent)]
20711pub struct DisplayPlaneInfo2KHRBuilder<'a> {
20712    inner: DisplayPlaneInfo2KHR,
20713    marker: ::std::marker::PhantomData<&'a ()>,
20714}
20715impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> {
20716    type Target = DisplayPlaneInfo2KHR;
20717    fn deref(&self) -> &Self::Target {
20718        &self.inner
20719    }
20720}
20721impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> {
20722    fn deref_mut(&mut self) -> &mut Self::Target {
20723        &mut self.inner
20724    }
20725}
20726impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
20727    pub fn mode(mut self, mode: DisplayModeKHR) -> Self {
20728        self.inner.mode = mode;
20729        self
20730    }
20731    pub fn plane_index(mut self, plane_index: u32) -> Self {
20732        self.inner.plane_index = plane_index;
20733        self
20734    }
20735    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20736    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20737    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20738    pub fn build(self) -> DisplayPlaneInfo2KHR {
20739        self.inner
20740    }
20741}
20742#[repr(C)]
20743#[cfg_attr(feature = "debug", derive(Debug))]
20744#[derive(Copy, Clone)]
20745#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html>"]
20746pub struct DisplayPlaneCapabilities2KHR {
20747    pub s_type: StructureType,
20748    pub p_next: *mut c_void,
20749    pub capabilities: DisplayPlaneCapabilitiesKHR,
20750}
20751impl ::std::default::Default for DisplayPlaneCapabilities2KHR {
20752    fn default() -> Self {
20753        Self {
20754            s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR,
20755            p_next: ::std::ptr::null_mut(),
20756            capabilities: DisplayPlaneCapabilitiesKHR::default(),
20757        }
20758    }
20759}
20760impl DisplayPlaneCapabilities2KHR {
20761    pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> {
20762        DisplayPlaneCapabilities2KHRBuilder {
20763            inner: Self::default(),
20764            marker: ::std::marker::PhantomData,
20765        }
20766    }
20767}
20768#[repr(transparent)]
20769pub struct DisplayPlaneCapabilities2KHRBuilder<'a> {
20770    inner: DisplayPlaneCapabilities2KHR,
20771    marker: ::std::marker::PhantomData<&'a ()>,
20772}
20773impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> {
20774    type Target = DisplayPlaneCapabilities2KHR;
20775    fn deref(&self) -> &Self::Target {
20776        &self.inner
20777    }
20778}
20779impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> {
20780    fn deref_mut(&mut self) -> &mut Self::Target {
20781        &mut self.inner
20782    }
20783}
20784impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
20785    pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self {
20786        self.inner.capabilities = capabilities;
20787        self
20788    }
20789    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20790    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20791    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20792    pub fn build(self) -> DisplayPlaneCapabilities2KHR {
20793        self.inner
20794    }
20795}
20796#[repr(C)]
20797#[cfg_attr(feature = "debug", derive(Debug))]
20798#[derive(Copy, Clone)]
20799#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>"]
20800pub struct SharedPresentSurfaceCapabilitiesKHR {
20801    pub s_type: StructureType,
20802    pub p_next: *mut c_void,
20803    pub shared_present_supported_usage_flags: ImageUsageFlags,
20804}
20805impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR {
20806    fn default() -> Self {
20807        Self {
20808            s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
20809            p_next: ::std::ptr::null_mut(),
20810            shared_present_supported_usage_flags: ImageUsageFlags::default(),
20811        }
20812    }
20813}
20814impl SharedPresentSurfaceCapabilitiesKHR {
20815    pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20816        SharedPresentSurfaceCapabilitiesKHRBuilder {
20817            inner: Self::default(),
20818            marker: ::std::marker::PhantomData,
20819        }
20820    }
20821}
20822#[repr(transparent)]
20823pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20824    inner: SharedPresentSurfaceCapabilitiesKHR,
20825    marker: ::std::marker::PhantomData<&'a ()>,
20826}
20827unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {}
20828unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {}
20829impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20830    type Target = SharedPresentSurfaceCapabilitiesKHR;
20831    fn deref(&self) -> &Self::Target {
20832        &self.inner
20833    }
20834}
20835impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20836    fn deref_mut(&mut self) -> &mut Self::Target {
20837        &mut self.inner
20838    }
20839}
20840impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
20841    pub fn shared_present_supported_usage_flags(
20842        mut self,
20843        shared_present_supported_usage_flags: ImageUsageFlags,
20844    ) -> Self {
20845        self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags;
20846        self
20847    }
20848    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20849    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20850    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20851    pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR {
20852        self.inner
20853    }
20854}
20855#[repr(C)]
20856#[cfg_attr(feature = "debug", derive(Debug))]
20857#[derive(Copy, Clone)]
20858#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html>"]
20859pub struct PhysicalDevice16BitStorageFeatures {
20860    pub s_type: StructureType,
20861    pub p_next: *mut c_void,
20862    pub storage_buffer16_bit_access: Bool32,
20863    pub uniform_and_storage_buffer16_bit_access: Bool32,
20864    pub storage_push_constant16: Bool32,
20865    pub storage_input_output16: Bool32,
20866}
20867impl ::std::default::Default for PhysicalDevice16BitStorageFeatures {
20868    fn default() -> Self {
20869        Self {
20870            s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
20871            p_next: ::std::ptr::null_mut(),
20872            storage_buffer16_bit_access: Bool32::default(),
20873            uniform_and_storage_buffer16_bit_access: Bool32::default(),
20874            storage_push_constant16: Bool32::default(),
20875            storage_input_output16: Bool32::default(),
20876        }
20877    }
20878}
20879impl PhysicalDevice16BitStorageFeatures {
20880    pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20881        PhysicalDevice16BitStorageFeaturesBuilder {
20882            inner: Self::default(),
20883            marker: ::std::marker::PhantomData,
20884        }
20885    }
20886}
20887#[repr(transparent)]
20888pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20889    inner: PhysicalDevice16BitStorageFeatures,
20890    marker: ::std::marker::PhantomData<&'a ()>,
20891}
20892unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
20893unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {}
20894unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
20895unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {}
20896impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20897    type Target = PhysicalDevice16BitStorageFeatures;
20898    fn deref(&self) -> &Self::Target {
20899        &self.inner
20900    }
20901}
20902impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20903    fn deref_mut(&mut self) -> &mut Self::Target {
20904        &mut self.inner
20905    }
20906}
20907impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
20908    pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
20909        self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
20910        self
20911    }
20912    pub fn uniform_and_storage_buffer16_bit_access(
20913        mut self,
20914        uniform_and_storage_buffer16_bit_access: bool,
20915    ) -> Self {
20916        self.inner.uniform_and_storage_buffer16_bit_access =
20917            uniform_and_storage_buffer16_bit_access.into();
20918        self
20919    }
20920    pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
20921        self.inner.storage_push_constant16 = storage_push_constant16.into();
20922        self
20923    }
20924    pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
20925        self.inner.storage_input_output16 = storage_input_output16.into();
20926        self
20927    }
20928    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20929    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20930    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
20931    pub fn build(self) -> PhysicalDevice16BitStorageFeatures {
20932        self.inner
20933    }
20934}
20935#[repr(C)]
20936#[cfg_attr(feature = "debug", derive(Debug))]
20937#[derive(Copy, Clone)]
20938#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html>"]
20939pub struct PhysicalDeviceSubgroupProperties {
20940    pub s_type: StructureType,
20941    pub p_next: *mut c_void,
20942    pub subgroup_size: u32,
20943    pub supported_stages: ShaderStageFlags,
20944    pub supported_operations: SubgroupFeatureFlags,
20945    pub quad_operations_in_all_stages: Bool32,
20946}
20947impl ::std::default::Default for PhysicalDeviceSubgroupProperties {
20948    fn default() -> Self {
20949        Self {
20950            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
20951            p_next: ::std::ptr::null_mut(),
20952            subgroup_size: u32::default(),
20953            supported_stages: ShaderStageFlags::default(),
20954            supported_operations: SubgroupFeatureFlags::default(),
20955            quad_operations_in_all_stages: Bool32::default(),
20956        }
20957    }
20958}
20959impl PhysicalDeviceSubgroupProperties {
20960    pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20961        PhysicalDeviceSubgroupPropertiesBuilder {
20962            inner: Self::default(),
20963            marker: ::std::marker::PhantomData,
20964        }
20965    }
20966}
20967#[repr(transparent)]
20968pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20969    inner: PhysicalDeviceSubgroupProperties,
20970    marker: ::std::marker::PhantomData<&'a ()>,
20971}
20972unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {}
20973unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {}
20974impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20975    type Target = PhysicalDeviceSubgroupProperties;
20976    fn deref(&self) -> &Self::Target {
20977        &self.inner
20978    }
20979}
20980impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20981    fn deref_mut(&mut self) -> &mut Self::Target {
20982        &mut self.inner
20983    }
20984}
20985impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
20986    pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
20987        self.inner.subgroup_size = subgroup_size;
20988        self
20989    }
20990    pub fn supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self {
20991        self.inner.supported_stages = supported_stages;
20992        self
20993    }
20994    pub fn supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self {
20995        self.inner.supported_operations = supported_operations;
20996        self
20997    }
20998    pub fn quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self {
20999        self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into();
21000        self
21001    }
21002    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21003    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21004    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21005    pub fn build(self) -> PhysicalDeviceSubgroupProperties {
21006        self.inner
21007    }
21008}
21009#[repr(C)]
21010#[cfg_attr(feature = "debug", derive(Debug))]
21011#[derive(Copy, Clone)]
21012#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>"]
21013pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21014    pub s_type: StructureType,
21015    pub p_next: *mut c_void,
21016    pub shader_subgroup_extended_types: Bool32,
21017}
21018impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21019    fn default() -> Self {
21020        Self {
21021            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
21022            p_next: ::std::ptr::null_mut(),
21023            shader_subgroup_extended_types: Bool32::default(),
21024        }
21025    }
21026}
21027impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21028    pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21029        PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder {
21030            inner: Self::default(),
21031            marker: ::std::marker::PhantomData,
21032        }
21033    }
21034}
21035#[repr(transparent)]
21036pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21037    inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
21038    marker: ::std::marker::PhantomData<&'a ()>,
21039}
21040unsafe impl ExtendsPhysicalDeviceFeatures2
21041    for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
21042{
21043}
21044unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
21045unsafe impl ExtendsDeviceCreateInfo
21046    for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
21047{
21048}
21049unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
21050impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21051    type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
21052    fn deref(&self) -> &Self::Target {
21053        &self.inner
21054    }
21055}
21056impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21057    fn deref_mut(&mut self) -> &mut Self::Target {
21058        &mut self.inner
21059    }
21060}
21061impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
21062    pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
21063        self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
21064        self
21065    }
21066    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21067    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21068    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21069    pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
21070        self.inner
21071    }
21072}
21073#[repr(C)]
21074#[cfg_attr(feature = "debug", derive(Debug))]
21075#[derive(Copy, Clone)]
21076#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryRequirementsInfo2.html>"]
21077pub struct BufferMemoryRequirementsInfo2 {
21078    pub s_type: StructureType,
21079    pub p_next: *const c_void,
21080    pub buffer: Buffer,
21081}
21082impl ::std::default::Default for BufferMemoryRequirementsInfo2 {
21083    fn default() -> Self {
21084        Self {
21085            s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2,
21086            p_next: ::std::ptr::null(),
21087            buffer: Buffer::default(),
21088        }
21089    }
21090}
21091impl BufferMemoryRequirementsInfo2 {
21092    pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> {
21093        BufferMemoryRequirementsInfo2Builder {
21094            inner: Self::default(),
21095            marker: ::std::marker::PhantomData,
21096        }
21097    }
21098}
21099#[repr(transparent)]
21100pub struct BufferMemoryRequirementsInfo2Builder<'a> {
21101    inner: BufferMemoryRequirementsInfo2,
21102    marker: ::std::marker::PhantomData<&'a ()>,
21103}
21104impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> {
21105    type Target = BufferMemoryRequirementsInfo2;
21106    fn deref(&self) -> &Self::Target {
21107        &self.inner
21108    }
21109}
21110impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> {
21111    fn deref_mut(&mut self) -> &mut Self::Target {
21112        &mut self.inner
21113    }
21114}
21115impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
21116    pub fn buffer(mut self, buffer: Buffer) -> Self {
21117        self.inner.buffer = buffer;
21118        self
21119    }
21120    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21121    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21122    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21123    pub fn build(self) -> BufferMemoryRequirementsInfo2 {
21124        self.inner
21125    }
21126}
21127#[repr(C)]
21128#[cfg_attr(feature = "debug", derive(Debug))]
21129#[derive(Copy, Clone)]
21130#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceBufferMemoryRequirements.html>"]
21131pub struct DeviceBufferMemoryRequirements {
21132    pub s_type: StructureType,
21133    pub p_next: *const c_void,
21134    pub p_create_info: *const BufferCreateInfo,
21135}
21136impl ::std::default::Default for DeviceBufferMemoryRequirements {
21137    fn default() -> Self {
21138        Self {
21139            s_type: StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS,
21140            p_next: ::std::ptr::null(),
21141            p_create_info: ::std::ptr::null(),
21142        }
21143    }
21144}
21145impl DeviceBufferMemoryRequirements {
21146    pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> {
21147        DeviceBufferMemoryRequirementsBuilder {
21148            inner: Self::default(),
21149            marker: ::std::marker::PhantomData,
21150        }
21151    }
21152}
21153#[repr(transparent)]
21154pub struct DeviceBufferMemoryRequirementsBuilder<'a> {
21155    inner: DeviceBufferMemoryRequirements,
21156    marker: ::std::marker::PhantomData<&'a ()>,
21157}
21158impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> {
21159    type Target = DeviceBufferMemoryRequirements;
21160    fn deref(&self) -> &Self::Target {
21161        &self.inner
21162    }
21163}
21164impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> {
21165    fn deref_mut(&mut self) -> &mut Self::Target {
21166        &mut self.inner
21167    }
21168}
21169impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> {
21170    pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self {
21171        self.inner.p_create_info = create_info;
21172        self
21173    }
21174    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21175    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21176    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21177    pub fn build(self) -> DeviceBufferMemoryRequirements {
21178        self.inner
21179    }
21180}
21181#[repr(C)]
21182#[cfg_attr(feature = "debug", derive(Debug))]
21183#[derive(Copy, Clone)]
21184#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryRequirementsInfo2.html>"]
21185pub struct ImageMemoryRequirementsInfo2 {
21186    pub s_type: StructureType,
21187    pub p_next: *const c_void,
21188    pub image: Image,
21189}
21190impl ::std::default::Default for ImageMemoryRequirementsInfo2 {
21191    fn default() -> Self {
21192        Self {
21193            s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2,
21194            p_next: ::std::ptr::null(),
21195            image: Image::default(),
21196        }
21197    }
21198}
21199impl ImageMemoryRequirementsInfo2 {
21200    pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> {
21201        ImageMemoryRequirementsInfo2Builder {
21202            inner: Self::default(),
21203            marker: ::std::marker::PhantomData,
21204        }
21205    }
21206}
21207#[repr(transparent)]
21208pub struct ImageMemoryRequirementsInfo2Builder<'a> {
21209    inner: ImageMemoryRequirementsInfo2,
21210    marker: ::std::marker::PhantomData<&'a ()>,
21211}
21212pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {}
21213impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> {
21214    type Target = ImageMemoryRequirementsInfo2;
21215    fn deref(&self) -> &Self::Target {
21216        &self.inner
21217    }
21218}
21219impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> {
21220    fn deref_mut(&mut self) -> &mut Self::Target {
21221        &mut self.inner
21222    }
21223}
21224impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
21225    pub fn image(mut self, image: Image) -> Self {
21226        self.inner.image = image;
21227        self
21228    }
21229    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21230    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21231    #[doc = r" valid extension structs can be pushed into the chain."]
21232    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21233    #[doc = r" chain will look like `A -> D -> B -> C`."]
21234    pub fn push_next<T: ExtendsImageMemoryRequirementsInfo2>(mut self, next: &'a mut T) -> Self {
21235        unsafe {
21236            let next_ptr = <*const T>::cast(next);
21237            let last_next = ptr_chain_iter(next).last().unwrap();
21238            (*last_next).p_next = self.inner.p_next as _;
21239            self.inner.p_next = next_ptr;
21240        }
21241        self
21242    }
21243    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21244    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21245    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21246    pub fn build(self) -> ImageMemoryRequirementsInfo2 {
21247        self.inner
21248    }
21249}
21250#[repr(C)]
21251#[cfg_attr(feature = "debug", derive(Debug))]
21252#[derive(Copy, Clone)]
21253#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html>"]
21254pub struct ImageSparseMemoryRequirementsInfo2 {
21255    pub s_type: StructureType,
21256    pub p_next: *const c_void,
21257    pub image: Image,
21258}
21259impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 {
21260    fn default() -> Self {
21261        Self {
21262            s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
21263            p_next: ::std::ptr::null(),
21264            image: Image::default(),
21265        }
21266    }
21267}
21268impl ImageSparseMemoryRequirementsInfo2 {
21269    pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
21270        ImageSparseMemoryRequirementsInfo2Builder {
21271            inner: Self::default(),
21272            marker: ::std::marker::PhantomData,
21273        }
21274    }
21275}
21276#[repr(transparent)]
21277pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> {
21278    inner: ImageSparseMemoryRequirementsInfo2,
21279    marker: ::std::marker::PhantomData<&'a ()>,
21280}
21281impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> {
21282    type Target = ImageSparseMemoryRequirementsInfo2;
21283    fn deref(&self) -> &Self::Target {
21284        &self.inner
21285    }
21286}
21287impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> {
21288    fn deref_mut(&mut self) -> &mut Self::Target {
21289        &mut self.inner
21290    }
21291}
21292impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
21293    pub fn image(mut self, image: Image) -> Self {
21294        self.inner.image = image;
21295        self
21296    }
21297    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21298    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21299    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21300    pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 {
21301        self.inner
21302    }
21303}
21304#[repr(C)]
21305#[cfg_attr(feature = "debug", derive(Debug))]
21306#[derive(Copy, Clone)]
21307#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceImageMemoryRequirements.html>"]
21308pub struct DeviceImageMemoryRequirements {
21309    pub s_type: StructureType,
21310    pub p_next: *const c_void,
21311    pub p_create_info: *const ImageCreateInfo,
21312    pub plane_aspect: ImageAspectFlags,
21313}
21314impl ::std::default::Default for DeviceImageMemoryRequirements {
21315    fn default() -> Self {
21316        Self {
21317            s_type: StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS,
21318            p_next: ::std::ptr::null(),
21319            p_create_info: ::std::ptr::null(),
21320            plane_aspect: ImageAspectFlags::default(),
21321        }
21322    }
21323}
21324impl DeviceImageMemoryRequirements {
21325    pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> {
21326        DeviceImageMemoryRequirementsBuilder {
21327            inner: Self::default(),
21328            marker: ::std::marker::PhantomData,
21329        }
21330    }
21331}
21332#[repr(transparent)]
21333pub struct DeviceImageMemoryRequirementsBuilder<'a> {
21334    inner: DeviceImageMemoryRequirements,
21335    marker: ::std::marker::PhantomData<&'a ()>,
21336}
21337impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> {
21338    type Target = DeviceImageMemoryRequirements;
21339    fn deref(&self) -> &Self::Target {
21340        &self.inner
21341    }
21342}
21343impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> {
21344    fn deref_mut(&mut self) -> &mut Self::Target {
21345        &mut self.inner
21346    }
21347}
21348impl<'a> DeviceImageMemoryRequirementsBuilder<'a> {
21349    pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self {
21350        self.inner.p_create_info = create_info;
21351        self
21352    }
21353    pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
21354        self.inner.plane_aspect = plane_aspect;
21355        self
21356    }
21357    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21358    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21359    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21360    pub fn build(self) -> DeviceImageMemoryRequirements {
21361        self.inner
21362    }
21363}
21364#[repr(C)]
21365#[cfg_attr(feature = "debug", derive(Debug))]
21366#[derive(Copy, Clone)]
21367#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements2.html>"]
21368pub struct MemoryRequirements2 {
21369    pub s_type: StructureType,
21370    pub p_next: *mut c_void,
21371    pub memory_requirements: MemoryRequirements,
21372}
21373impl ::std::default::Default for MemoryRequirements2 {
21374    fn default() -> Self {
21375        Self {
21376            s_type: StructureType::MEMORY_REQUIREMENTS_2,
21377            p_next: ::std::ptr::null_mut(),
21378            memory_requirements: MemoryRequirements::default(),
21379        }
21380    }
21381}
21382impl MemoryRequirements2 {
21383    pub fn builder<'a>() -> MemoryRequirements2Builder<'a> {
21384        MemoryRequirements2Builder {
21385            inner: Self::default(),
21386            marker: ::std::marker::PhantomData,
21387        }
21388    }
21389}
21390#[repr(transparent)]
21391pub struct MemoryRequirements2Builder<'a> {
21392    inner: MemoryRequirements2,
21393    marker: ::std::marker::PhantomData<&'a ()>,
21394}
21395pub unsafe trait ExtendsMemoryRequirements2 {}
21396impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> {
21397    type Target = MemoryRequirements2;
21398    fn deref(&self) -> &Self::Target {
21399        &self.inner
21400    }
21401}
21402impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> {
21403    fn deref_mut(&mut self) -> &mut Self::Target {
21404        &mut self.inner
21405    }
21406}
21407impl<'a> MemoryRequirements2Builder<'a> {
21408    pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self {
21409        self.inner.memory_requirements = memory_requirements;
21410        self
21411    }
21412    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21413    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21414    #[doc = r" valid extension structs can be pushed into the chain."]
21415    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21416    #[doc = r" chain will look like `A -> D -> B -> C`."]
21417    pub fn push_next<T: ExtendsMemoryRequirements2>(mut self, next: &'a mut T) -> Self {
21418        unsafe {
21419            let next_ptr = <*mut T>::cast(next);
21420            let last_next = ptr_chain_iter(next).last().unwrap();
21421            (*last_next).p_next = self.inner.p_next as _;
21422            self.inner.p_next = next_ptr;
21423        }
21424        self
21425    }
21426    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21427    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21428    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21429    pub fn build(self) -> MemoryRequirements2 {
21430        self.inner
21431    }
21432}
21433#[repr(C)]
21434#[cfg_attr(feature = "debug", derive(Debug))]
21435#[derive(Copy, Clone)]
21436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements2.html>"]
21437pub struct SparseImageMemoryRequirements2 {
21438    pub s_type: StructureType,
21439    pub p_next: *mut c_void,
21440    pub memory_requirements: SparseImageMemoryRequirements,
21441}
21442impl ::std::default::Default for SparseImageMemoryRequirements2 {
21443    fn default() -> Self {
21444        Self {
21445            s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
21446            p_next: ::std::ptr::null_mut(),
21447            memory_requirements: SparseImageMemoryRequirements::default(),
21448        }
21449    }
21450}
21451impl SparseImageMemoryRequirements2 {
21452    pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> {
21453        SparseImageMemoryRequirements2Builder {
21454            inner: Self::default(),
21455            marker: ::std::marker::PhantomData,
21456        }
21457    }
21458}
21459#[repr(transparent)]
21460pub struct SparseImageMemoryRequirements2Builder<'a> {
21461    inner: SparseImageMemoryRequirements2,
21462    marker: ::std::marker::PhantomData<&'a ()>,
21463}
21464impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> {
21465    type Target = SparseImageMemoryRequirements2;
21466    fn deref(&self) -> &Self::Target {
21467        &self.inner
21468    }
21469}
21470impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> {
21471    fn deref_mut(&mut self) -> &mut Self::Target {
21472        &mut self.inner
21473    }
21474}
21475impl<'a> SparseImageMemoryRequirements2Builder<'a> {
21476    pub fn memory_requirements(
21477        mut self,
21478        memory_requirements: SparseImageMemoryRequirements,
21479    ) -> Self {
21480        self.inner.memory_requirements = memory_requirements;
21481        self
21482    }
21483    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21484    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21485    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21486    pub fn build(self) -> SparseImageMemoryRequirements2 {
21487        self.inner
21488    }
21489}
21490#[repr(C)]
21491#[cfg_attr(feature = "debug", derive(Debug))]
21492#[derive(Copy, Clone)]
21493#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePointClippingProperties.html>"]
21494pub struct PhysicalDevicePointClippingProperties {
21495    pub s_type: StructureType,
21496    pub p_next: *mut c_void,
21497    pub point_clipping_behavior: PointClippingBehavior,
21498}
21499impl ::std::default::Default for PhysicalDevicePointClippingProperties {
21500    fn default() -> Self {
21501        Self {
21502            s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
21503            p_next: ::std::ptr::null_mut(),
21504            point_clipping_behavior: PointClippingBehavior::default(),
21505        }
21506    }
21507}
21508impl PhysicalDevicePointClippingProperties {
21509    pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
21510        PhysicalDevicePointClippingPropertiesBuilder {
21511            inner: Self::default(),
21512            marker: ::std::marker::PhantomData,
21513        }
21514    }
21515}
21516#[repr(transparent)]
21517pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> {
21518    inner: PhysicalDevicePointClippingProperties,
21519    marker: ::std::marker::PhantomData<&'a ()>,
21520}
21521unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {}
21522unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {}
21523impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> {
21524    type Target = PhysicalDevicePointClippingProperties;
21525    fn deref(&self) -> &Self::Target {
21526        &self.inner
21527    }
21528}
21529impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> {
21530    fn deref_mut(&mut self) -> &mut Self::Target {
21531        &mut self.inner
21532    }
21533}
21534impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
21535    pub fn point_clipping_behavior(
21536        mut self,
21537        point_clipping_behavior: PointClippingBehavior,
21538    ) -> Self {
21539        self.inner.point_clipping_behavior = point_clipping_behavior;
21540        self
21541    }
21542    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21543    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21544    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21545    pub fn build(self) -> PhysicalDevicePointClippingProperties {
21546        self.inner
21547    }
21548}
21549#[repr(C)]
21550#[cfg_attr(feature = "debug", derive(Debug))]
21551#[derive(Copy, Clone)]
21552#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedRequirements.html>"]
21553pub struct MemoryDedicatedRequirements {
21554    pub s_type: StructureType,
21555    pub p_next: *mut c_void,
21556    pub prefers_dedicated_allocation: Bool32,
21557    pub requires_dedicated_allocation: Bool32,
21558}
21559impl ::std::default::Default for MemoryDedicatedRequirements {
21560    fn default() -> Self {
21561        Self {
21562            s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS,
21563            p_next: ::std::ptr::null_mut(),
21564            prefers_dedicated_allocation: Bool32::default(),
21565            requires_dedicated_allocation: Bool32::default(),
21566        }
21567    }
21568}
21569impl MemoryDedicatedRequirements {
21570    pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> {
21571        MemoryDedicatedRequirementsBuilder {
21572            inner: Self::default(),
21573            marker: ::std::marker::PhantomData,
21574        }
21575    }
21576}
21577#[repr(transparent)]
21578pub struct MemoryDedicatedRequirementsBuilder<'a> {
21579    inner: MemoryDedicatedRequirements,
21580    marker: ::std::marker::PhantomData<&'a ()>,
21581}
21582unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {}
21583unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {}
21584impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> {
21585    type Target = MemoryDedicatedRequirements;
21586    fn deref(&self) -> &Self::Target {
21587        &self.inner
21588    }
21589}
21590impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> {
21591    fn deref_mut(&mut self) -> &mut Self::Target {
21592        &mut self.inner
21593    }
21594}
21595impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
21596    pub fn prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self {
21597        self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into();
21598        self
21599    }
21600    pub fn requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self {
21601        self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into();
21602        self
21603    }
21604    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21605    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21606    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21607    pub fn build(self) -> MemoryDedicatedRequirements {
21608        self.inner
21609    }
21610}
21611#[repr(C)]
21612#[cfg_attr(feature = "debug", derive(Debug))]
21613#[derive(Copy, Clone)]
21614#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedAllocateInfo.html>"]
21615pub struct MemoryDedicatedAllocateInfo {
21616    pub s_type: StructureType,
21617    pub p_next: *const c_void,
21618    pub image: Image,
21619    pub buffer: Buffer,
21620}
21621impl ::std::default::Default for MemoryDedicatedAllocateInfo {
21622    fn default() -> Self {
21623        Self {
21624            s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO,
21625            p_next: ::std::ptr::null(),
21626            image: Image::default(),
21627            buffer: Buffer::default(),
21628        }
21629    }
21630}
21631impl MemoryDedicatedAllocateInfo {
21632    pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> {
21633        MemoryDedicatedAllocateInfoBuilder {
21634            inner: Self::default(),
21635            marker: ::std::marker::PhantomData,
21636        }
21637    }
21638}
21639#[repr(transparent)]
21640pub struct MemoryDedicatedAllocateInfoBuilder<'a> {
21641    inner: MemoryDedicatedAllocateInfo,
21642    marker: ::std::marker::PhantomData<&'a ()>,
21643}
21644unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {}
21645unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {}
21646impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> {
21647    type Target = MemoryDedicatedAllocateInfo;
21648    fn deref(&self) -> &Self::Target {
21649        &self.inner
21650    }
21651}
21652impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> {
21653    fn deref_mut(&mut self) -> &mut Self::Target {
21654        &mut self.inner
21655    }
21656}
21657impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
21658    pub fn image(mut self, image: Image) -> Self {
21659        self.inner.image = image;
21660        self
21661    }
21662    pub fn buffer(mut self, buffer: Buffer) -> Self {
21663        self.inner.buffer = buffer;
21664        self
21665    }
21666    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21667    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21668    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21669    pub fn build(self) -> MemoryDedicatedAllocateInfo {
21670        self.inner
21671    }
21672}
21673#[repr(C)]
21674#[cfg_attr(feature = "debug", derive(Debug))]
21675#[derive(Copy, Clone)]
21676#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewUsageCreateInfo.html>"]
21677pub struct ImageViewUsageCreateInfo {
21678    pub s_type: StructureType,
21679    pub p_next: *const c_void,
21680    pub usage: ImageUsageFlags,
21681}
21682impl ::std::default::Default for ImageViewUsageCreateInfo {
21683    fn default() -> Self {
21684        Self {
21685            s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO,
21686            p_next: ::std::ptr::null(),
21687            usage: ImageUsageFlags::default(),
21688        }
21689    }
21690}
21691impl ImageViewUsageCreateInfo {
21692    pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> {
21693        ImageViewUsageCreateInfoBuilder {
21694            inner: Self::default(),
21695            marker: ::std::marker::PhantomData,
21696        }
21697    }
21698}
21699#[repr(transparent)]
21700pub struct ImageViewUsageCreateInfoBuilder<'a> {
21701    inner: ImageViewUsageCreateInfo,
21702    marker: ::std::marker::PhantomData<&'a ()>,
21703}
21704unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {}
21705unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {}
21706impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> {
21707    type Target = ImageViewUsageCreateInfo;
21708    fn deref(&self) -> &Self::Target {
21709        &self.inner
21710    }
21711}
21712impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> {
21713    fn deref_mut(&mut self) -> &mut Self::Target {
21714        &mut self.inner
21715    }
21716}
21717impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
21718    pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
21719        self.inner.usage = usage;
21720        self
21721    }
21722    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21723    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21724    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21725    pub fn build(self) -> ImageViewUsageCreateInfo {
21726        self.inner
21727    }
21728}
21729#[repr(C)]
21730#[cfg_attr(feature = "debug", derive(Debug))]
21731#[derive(Copy, Clone)]
21732#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>"]
21733pub struct PipelineTessellationDomainOriginStateCreateInfo {
21734    pub s_type: StructureType,
21735    pub p_next: *const c_void,
21736    pub domain_origin: TessellationDomainOrigin,
21737}
21738impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo {
21739    fn default() -> Self {
21740        Self {
21741            s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
21742            p_next: ::std::ptr::null(),
21743            domain_origin: TessellationDomainOrigin::default(),
21744        }
21745    }
21746}
21747impl PipelineTessellationDomainOriginStateCreateInfo {
21748    pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21749        PipelineTessellationDomainOriginStateCreateInfoBuilder {
21750            inner: Self::default(),
21751            marker: ::std::marker::PhantomData,
21752        }
21753    }
21754}
21755#[repr(transparent)]
21756pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21757    inner: PipelineTessellationDomainOriginStateCreateInfo,
21758    marker: ::std::marker::PhantomData<&'a ()>,
21759}
21760unsafe impl ExtendsPipelineTessellationStateCreateInfo
21761    for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_>
21762{
21763}
21764unsafe impl ExtendsPipelineTessellationStateCreateInfo
21765    for PipelineTessellationDomainOriginStateCreateInfo
21766{
21767}
21768impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21769    type Target = PipelineTessellationDomainOriginStateCreateInfo;
21770    fn deref(&self) -> &Self::Target {
21771        &self.inner
21772    }
21773}
21774impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21775    fn deref_mut(&mut self) -> &mut Self::Target {
21776        &mut self.inner
21777    }
21778}
21779impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
21780    pub fn domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self {
21781        self.inner.domain_origin = domain_origin;
21782        self
21783    }
21784    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21785    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21786    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21787    pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo {
21788        self.inner
21789    }
21790}
21791#[repr(C)]
21792#[cfg_attr(feature = "debug", derive(Debug))]
21793#[derive(Copy, Clone)]
21794#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionInfo.html>"]
21795pub struct SamplerYcbcrConversionInfo {
21796    pub s_type: StructureType,
21797    pub p_next: *const c_void,
21798    pub conversion: SamplerYcbcrConversion,
21799}
21800impl ::std::default::Default for SamplerYcbcrConversionInfo {
21801    fn default() -> Self {
21802        Self {
21803            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO,
21804            p_next: ::std::ptr::null(),
21805            conversion: SamplerYcbcrConversion::default(),
21806        }
21807    }
21808}
21809impl SamplerYcbcrConversionInfo {
21810    pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> {
21811        SamplerYcbcrConversionInfoBuilder {
21812            inner: Self::default(),
21813            marker: ::std::marker::PhantomData,
21814        }
21815    }
21816}
21817#[repr(transparent)]
21818pub struct SamplerYcbcrConversionInfoBuilder<'a> {
21819    inner: SamplerYcbcrConversionInfo,
21820    marker: ::std::marker::PhantomData<&'a ()>,
21821}
21822unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
21823unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {}
21824unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
21825unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {}
21826impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> {
21827    type Target = SamplerYcbcrConversionInfo;
21828    fn deref(&self) -> &Self::Target {
21829        &self.inner
21830    }
21831}
21832impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> {
21833    fn deref_mut(&mut self) -> &mut Self::Target {
21834        &mut self.inner
21835    }
21836}
21837impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
21838    pub fn conversion(mut self, conversion: SamplerYcbcrConversion) -> Self {
21839        self.inner.conversion = conversion;
21840        self
21841    }
21842    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21843    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21844    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21845    pub fn build(self) -> SamplerYcbcrConversionInfo {
21846        self.inner
21847    }
21848}
21849#[repr(C)]
21850#[cfg_attr(feature = "debug", derive(Debug))]
21851#[derive(Copy, Clone)]
21852#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html>"]
21853pub struct SamplerYcbcrConversionCreateInfo {
21854    pub s_type: StructureType,
21855    pub p_next: *const c_void,
21856    pub format: Format,
21857    pub ycbcr_model: SamplerYcbcrModelConversion,
21858    pub ycbcr_range: SamplerYcbcrRange,
21859    pub components: ComponentMapping,
21860    pub x_chroma_offset: ChromaLocation,
21861    pub y_chroma_offset: ChromaLocation,
21862    pub chroma_filter: Filter,
21863    pub force_explicit_reconstruction: Bool32,
21864}
21865impl ::std::default::Default for SamplerYcbcrConversionCreateInfo {
21866    fn default() -> Self {
21867        Self {
21868            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
21869            p_next: ::std::ptr::null(),
21870            format: Format::default(),
21871            ycbcr_model: SamplerYcbcrModelConversion::default(),
21872            ycbcr_range: SamplerYcbcrRange::default(),
21873            components: ComponentMapping::default(),
21874            x_chroma_offset: ChromaLocation::default(),
21875            y_chroma_offset: ChromaLocation::default(),
21876            chroma_filter: Filter::default(),
21877            force_explicit_reconstruction: Bool32::default(),
21878        }
21879    }
21880}
21881impl SamplerYcbcrConversionCreateInfo {
21882    pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
21883        SamplerYcbcrConversionCreateInfoBuilder {
21884            inner: Self::default(),
21885            marker: ::std::marker::PhantomData,
21886        }
21887    }
21888}
21889#[repr(transparent)]
21890pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> {
21891    inner: SamplerYcbcrConversionCreateInfo,
21892    marker: ::std::marker::PhantomData<&'a ()>,
21893}
21894pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {}
21895impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> {
21896    type Target = SamplerYcbcrConversionCreateInfo;
21897    fn deref(&self) -> &Self::Target {
21898        &self.inner
21899    }
21900}
21901impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> {
21902    fn deref_mut(&mut self) -> &mut Self::Target {
21903        &mut self.inner
21904    }
21905}
21906impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
21907    pub fn format(mut self, format: Format) -> Self {
21908        self.inner.format = format;
21909        self
21910    }
21911    pub fn ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self {
21912        self.inner.ycbcr_model = ycbcr_model;
21913        self
21914    }
21915    pub fn ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self {
21916        self.inner.ycbcr_range = ycbcr_range;
21917        self
21918    }
21919    pub fn components(mut self, components: ComponentMapping) -> Self {
21920        self.inner.components = components;
21921        self
21922    }
21923    pub fn x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self {
21924        self.inner.x_chroma_offset = x_chroma_offset;
21925        self
21926    }
21927    pub fn y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self {
21928        self.inner.y_chroma_offset = y_chroma_offset;
21929        self
21930    }
21931    pub fn chroma_filter(mut self, chroma_filter: Filter) -> Self {
21932        self.inner.chroma_filter = chroma_filter;
21933        self
21934    }
21935    pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self {
21936        self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into();
21937        self
21938    }
21939    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21940    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21941    #[doc = r" valid extension structs can be pushed into the chain."]
21942    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21943    #[doc = r" chain will look like `A -> D -> B -> C`."]
21944    pub fn push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>(
21945        mut self,
21946        next: &'a mut T,
21947    ) -> Self {
21948        unsafe {
21949            let next_ptr = <*const T>::cast(next);
21950            let last_next = ptr_chain_iter(next).last().unwrap();
21951            (*last_next).p_next = self.inner.p_next as _;
21952            self.inner.p_next = next_ptr;
21953        }
21954        self
21955    }
21956    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21957    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21958    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
21959    pub fn build(self) -> SamplerYcbcrConversionCreateInfo {
21960        self.inner
21961    }
21962}
21963#[repr(C)]
21964#[cfg_attr(feature = "debug", derive(Debug))]
21965#[derive(Copy, Clone)]
21966#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImagePlaneMemoryInfo.html>"]
21967pub struct BindImagePlaneMemoryInfo {
21968    pub s_type: StructureType,
21969    pub p_next: *const c_void,
21970    pub plane_aspect: ImageAspectFlags,
21971}
21972impl ::std::default::Default for BindImagePlaneMemoryInfo {
21973    fn default() -> Self {
21974        Self {
21975            s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO,
21976            p_next: ::std::ptr::null(),
21977            plane_aspect: ImageAspectFlags::default(),
21978        }
21979    }
21980}
21981impl BindImagePlaneMemoryInfo {
21982    pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> {
21983        BindImagePlaneMemoryInfoBuilder {
21984            inner: Self::default(),
21985            marker: ::std::marker::PhantomData,
21986        }
21987    }
21988}
21989#[repr(transparent)]
21990pub struct BindImagePlaneMemoryInfoBuilder<'a> {
21991    inner: BindImagePlaneMemoryInfo,
21992    marker: ::std::marker::PhantomData<&'a ()>,
21993}
21994unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {}
21995unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {}
21996impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> {
21997    type Target = BindImagePlaneMemoryInfo;
21998    fn deref(&self) -> &Self::Target {
21999        &self.inner
22000    }
22001}
22002impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> {
22003    fn deref_mut(&mut self) -> &mut Self::Target {
22004        &mut self.inner
22005    }
22006}
22007impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
22008    pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
22009        self.inner.plane_aspect = plane_aspect;
22010        self
22011    }
22012    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22013    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22014    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22015    pub fn build(self) -> BindImagePlaneMemoryInfo {
22016        self.inner
22017    }
22018}
22019#[repr(C)]
22020#[cfg_attr(feature = "debug", derive(Debug))]
22021#[derive(Copy, Clone)]
22022#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html>"]
22023pub struct ImagePlaneMemoryRequirementsInfo {
22024    pub s_type: StructureType,
22025    pub p_next: *const c_void,
22026    pub plane_aspect: ImageAspectFlags,
22027}
22028impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo {
22029    fn default() -> Self {
22030        Self {
22031            s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
22032            p_next: ::std::ptr::null(),
22033            plane_aspect: ImageAspectFlags::default(),
22034        }
22035    }
22036}
22037impl ImagePlaneMemoryRequirementsInfo {
22038    pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22039        ImagePlaneMemoryRequirementsInfoBuilder {
22040            inner: Self::default(),
22041            marker: ::std::marker::PhantomData,
22042        }
22043    }
22044}
22045#[repr(transparent)]
22046pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22047    inner: ImagePlaneMemoryRequirementsInfo,
22048    marker: ::std::marker::PhantomData<&'a ()>,
22049}
22050unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {}
22051unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {}
22052impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22053    type Target = ImagePlaneMemoryRequirementsInfo;
22054    fn deref(&self) -> &Self::Target {
22055        &self.inner
22056    }
22057}
22058impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22059    fn deref_mut(&mut self) -> &mut Self::Target {
22060        &mut self.inner
22061    }
22062}
22063impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
22064    pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
22065        self.inner.plane_aspect = plane_aspect;
22066        self
22067    }
22068    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22069    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22070    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22071    pub fn build(self) -> ImagePlaneMemoryRequirementsInfo {
22072        self.inner
22073    }
22074}
22075#[repr(C)]
22076#[cfg_attr(feature = "debug", derive(Debug))]
22077#[derive(Copy, Clone)]
22078#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>"]
22079pub struct PhysicalDeviceSamplerYcbcrConversionFeatures {
22080    pub s_type: StructureType,
22081    pub p_next: *mut c_void,
22082    pub sampler_ycbcr_conversion: Bool32,
22083}
22084impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures {
22085    fn default() -> Self {
22086        Self {
22087            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
22088            p_next: ::std::ptr::null_mut(),
22089            sampler_ycbcr_conversion: Bool32::default(),
22090        }
22091    }
22092}
22093impl PhysicalDeviceSamplerYcbcrConversionFeatures {
22094    pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22095        PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder {
22096            inner: Self::default(),
22097            marker: ::std::marker::PhantomData,
22098        }
22099    }
22100}
22101#[repr(transparent)]
22102pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22103    inner: PhysicalDeviceSamplerYcbcrConversionFeatures,
22104    marker: ::std::marker::PhantomData<&'a ()>,
22105}
22106unsafe impl ExtendsPhysicalDeviceFeatures2
22107    for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_>
22108{
22109}
22110unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {}
22111unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {}
22112unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {}
22113impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22114    type Target = PhysicalDeviceSamplerYcbcrConversionFeatures;
22115    fn deref(&self) -> &Self::Target {
22116        &self.inner
22117    }
22118}
22119impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22120    fn deref_mut(&mut self) -> &mut Self::Target {
22121        &mut self.inner
22122    }
22123}
22124impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
22125    pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
22126        self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
22127        self
22128    }
22129    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22130    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22131    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22132    pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures {
22133        self.inner
22134    }
22135}
22136#[repr(C)]
22137#[cfg_attr(feature = "debug", derive(Debug))]
22138#[derive(Copy, Clone)]
22139#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>"]
22140pub struct SamplerYcbcrConversionImageFormatProperties {
22141    pub s_type: StructureType,
22142    pub p_next: *mut c_void,
22143    pub combined_image_sampler_descriptor_count: u32,
22144}
22145impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties {
22146    fn default() -> Self {
22147        Self {
22148            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
22149            p_next: ::std::ptr::null_mut(),
22150            combined_image_sampler_descriptor_count: u32::default(),
22151        }
22152    }
22153}
22154impl SamplerYcbcrConversionImageFormatProperties {
22155    pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22156        SamplerYcbcrConversionImageFormatPropertiesBuilder {
22157            inner: Self::default(),
22158            marker: ::std::marker::PhantomData,
22159        }
22160    }
22161}
22162#[repr(transparent)]
22163pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22164    inner: SamplerYcbcrConversionImageFormatProperties,
22165    marker: ::std::marker::PhantomData<&'a ()>,
22166}
22167unsafe impl ExtendsImageFormatProperties2
22168    for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_>
22169{
22170}
22171unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {}
22172impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22173    type Target = SamplerYcbcrConversionImageFormatProperties;
22174    fn deref(&self) -> &Self::Target {
22175        &self.inner
22176    }
22177}
22178impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22179    fn deref_mut(&mut self) -> &mut Self::Target {
22180        &mut self.inner
22181    }
22182}
22183impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
22184    pub fn combined_image_sampler_descriptor_count(
22185        mut self,
22186        combined_image_sampler_descriptor_count: u32,
22187    ) -> Self {
22188        self.inner.combined_image_sampler_descriptor_count =
22189            combined_image_sampler_descriptor_count;
22190        self
22191    }
22192    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22193    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22194    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22195    pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties {
22196        self.inner
22197    }
22198}
22199#[repr(C)]
22200#[cfg_attr(feature = "debug", derive(Debug))]
22201#[derive(Copy, Clone)]
22202#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html>"]
22203pub struct TextureLODGatherFormatPropertiesAMD {
22204    pub s_type: StructureType,
22205    pub p_next: *mut c_void,
22206    pub supports_texture_gather_lod_bias_amd: Bool32,
22207}
22208impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD {
22209    fn default() -> Self {
22210        Self {
22211            s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
22212            p_next: ::std::ptr::null_mut(),
22213            supports_texture_gather_lod_bias_amd: Bool32::default(),
22214        }
22215    }
22216}
22217impl TextureLODGatherFormatPropertiesAMD {
22218    pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22219        TextureLODGatherFormatPropertiesAMDBuilder {
22220            inner: Self::default(),
22221            marker: ::std::marker::PhantomData,
22222        }
22223    }
22224}
22225#[repr(transparent)]
22226pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22227    inner: TextureLODGatherFormatPropertiesAMD,
22228    marker: ::std::marker::PhantomData<&'a ()>,
22229}
22230unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {}
22231unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {}
22232impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22233    type Target = TextureLODGatherFormatPropertiesAMD;
22234    fn deref(&self) -> &Self::Target {
22235        &self.inner
22236    }
22237}
22238impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22239    fn deref_mut(&mut self) -> &mut Self::Target {
22240        &mut self.inner
22241    }
22242}
22243impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
22244    pub fn supports_texture_gather_lod_bias_amd(
22245        mut self,
22246        supports_texture_gather_lod_bias_amd: bool,
22247    ) -> Self {
22248        self.inner.supports_texture_gather_lod_bias_amd =
22249            supports_texture_gather_lod_bias_amd.into();
22250        self
22251    }
22252    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22253    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22254    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22255    pub fn build(self) -> TextureLODGatherFormatPropertiesAMD {
22256        self.inner
22257    }
22258}
22259#[repr(C)]
22260#[cfg_attr(feature = "debug", derive(Debug))]
22261#[derive(Copy, Clone)]
22262#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html>"]
22263pub struct ConditionalRenderingBeginInfoEXT {
22264    pub s_type: StructureType,
22265    pub p_next: *const c_void,
22266    pub buffer: Buffer,
22267    pub offset: DeviceSize,
22268    pub flags: ConditionalRenderingFlagsEXT,
22269}
22270impl ::std::default::Default for ConditionalRenderingBeginInfoEXT {
22271    fn default() -> Self {
22272        Self {
22273            s_type: StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
22274            p_next: ::std::ptr::null(),
22275            buffer: Buffer::default(),
22276            offset: DeviceSize::default(),
22277            flags: ConditionalRenderingFlagsEXT::default(),
22278        }
22279    }
22280}
22281impl ConditionalRenderingBeginInfoEXT {
22282    pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
22283        ConditionalRenderingBeginInfoEXTBuilder {
22284            inner: Self::default(),
22285            marker: ::std::marker::PhantomData,
22286        }
22287    }
22288}
22289#[repr(transparent)]
22290pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> {
22291    inner: ConditionalRenderingBeginInfoEXT,
22292    marker: ::std::marker::PhantomData<&'a ()>,
22293}
22294impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> {
22295    type Target = ConditionalRenderingBeginInfoEXT;
22296    fn deref(&self) -> &Self::Target {
22297        &self.inner
22298    }
22299}
22300impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> {
22301    fn deref_mut(&mut self) -> &mut Self::Target {
22302        &mut self.inner
22303    }
22304}
22305impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
22306    pub fn buffer(mut self, buffer: Buffer) -> Self {
22307        self.inner.buffer = buffer;
22308        self
22309    }
22310    pub fn offset(mut self, offset: DeviceSize) -> Self {
22311        self.inner.offset = offset;
22312        self
22313    }
22314    pub fn flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self {
22315        self.inner.flags = flags;
22316        self
22317    }
22318    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22319    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22320    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22321    pub fn build(self) -> ConditionalRenderingBeginInfoEXT {
22322        self.inner
22323    }
22324}
22325#[repr(C)]
22326#[cfg_attr(feature = "debug", derive(Debug))]
22327#[derive(Copy, Clone)]
22328#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkProtectedSubmitInfo.html>"]
22329pub struct ProtectedSubmitInfo {
22330    pub s_type: StructureType,
22331    pub p_next: *const c_void,
22332    pub protected_submit: Bool32,
22333}
22334impl ::std::default::Default for ProtectedSubmitInfo {
22335    fn default() -> Self {
22336        Self {
22337            s_type: StructureType::PROTECTED_SUBMIT_INFO,
22338            p_next: ::std::ptr::null(),
22339            protected_submit: Bool32::default(),
22340        }
22341    }
22342}
22343impl ProtectedSubmitInfo {
22344    pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> {
22345        ProtectedSubmitInfoBuilder {
22346            inner: Self::default(),
22347            marker: ::std::marker::PhantomData,
22348        }
22349    }
22350}
22351#[repr(transparent)]
22352pub struct ProtectedSubmitInfoBuilder<'a> {
22353    inner: ProtectedSubmitInfo,
22354    marker: ::std::marker::PhantomData<&'a ()>,
22355}
22356unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {}
22357unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {}
22358impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> {
22359    type Target = ProtectedSubmitInfo;
22360    fn deref(&self) -> &Self::Target {
22361        &self.inner
22362    }
22363}
22364impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> {
22365    fn deref_mut(&mut self) -> &mut Self::Target {
22366        &mut self.inner
22367    }
22368}
22369impl<'a> ProtectedSubmitInfoBuilder<'a> {
22370    pub fn protected_submit(mut self, protected_submit: bool) -> Self {
22371        self.inner.protected_submit = protected_submit.into();
22372        self
22373    }
22374    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22375    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22376    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22377    pub fn build(self) -> ProtectedSubmitInfo {
22378        self.inner
22379    }
22380}
22381#[repr(C)]
22382#[cfg_attr(feature = "debug", derive(Debug))]
22383#[derive(Copy, Clone)]
22384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>"]
22385pub struct PhysicalDeviceProtectedMemoryFeatures {
22386    pub s_type: StructureType,
22387    pub p_next: *mut c_void,
22388    pub protected_memory: Bool32,
22389}
22390impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures {
22391    fn default() -> Self {
22392        Self {
22393            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
22394            p_next: ::std::ptr::null_mut(),
22395            protected_memory: Bool32::default(),
22396        }
22397    }
22398}
22399impl PhysicalDeviceProtectedMemoryFeatures {
22400    pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22401        PhysicalDeviceProtectedMemoryFeaturesBuilder {
22402            inner: Self::default(),
22403            marker: ::std::marker::PhantomData,
22404        }
22405    }
22406}
22407#[repr(transparent)]
22408pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22409    inner: PhysicalDeviceProtectedMemoryFeatures,
22410    marker: ::std::marker::PhantomData<&'a ()>,
22411}
22412unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
22413unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {}
22414unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
22415unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {}
22416impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22417    type Target = PhysicalDeviceProtectedMemoryFeatures;
22418    fn deref(&self) -> &Self::Target {
22419        &self.inner
22420    }
22421}
22422impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22423    fn deref_mut(&mut self) -> &mut Self::Target {
22424        &mut self.inner
22425    }
22426}
22427impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
22428    pub fn protected_memory(mut self, protected_memory: bool) -> Self {
22429        self.inner.protected_memory = protected_memory.into();
22430        self
22431    }
22432    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22433    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22434    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22435    pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures {
22436        self.inner
22437    }
22438}
22439#[repr(C)]
22440#[cfg_attr(feature = "debug", derive(Debug))]
22441#[derive(Copy, Clone)]
22442#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>"]
22443pub struct PhysicalDeviceProtectedMemoryProperties {
22444    pub s_type: StructureType,
22445    pub p_next: *mut c_void,
22446    pub protected_no_fault: Bool32,
22447}
22448impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties {
22449    fn default() -> Self {
22450        Self {
22451            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
22452            p_next: ::std::ptr::null_mut(),
22453            protected_no_fault: Bool32::default(),
22454        }
22455    }
22456}
22457impl PhysicalDeviceProtectedMemoryProperties {
22458    pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22459        PhysicalDeviceProtectedMemoryPropertiesBuilder {
22460            inner: Self::default(),
22461            marker: ::std::marker::PhantomData,
22462        }
22463    }
22464}
22465#[repr(transparent)]
22466pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22467    inner: PhysicalDeviceProtectedMemoryProperties,
22468    marker: ::std::marker::PhantomData<&'a ()>,
22469}
22470unsafe impl ExtendsPhysicalDeviceProperties2
22471    for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_>
22472{
22473}
22474unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {}
22475impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22476    type Target = PhysicalDeviceProtectedMemoryProperties;
22477    fn deref(&self) -> &Self::Target {
22478        &self.inner
22479    }
22480}
22481impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22482    fn deref_mut(&mut self) -> &mut Self::Target {
22483        &mut self.inner
22484    }
22485}
22486impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
22487    pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
22488        self.inner.protected_no_fault = protected_no_fault.into();
22489        self
22490    }
22491    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22492    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22493    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22494    pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties {
22495        self.inner
22496    }
22497}
22498#[repr(C)]
22499#[cfg_attr(feature = "debug", derive(Debug))]
22500#[derive(Copy, Clone)]
22501#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueInfo2.html>"]
22502pub struct DeviceQueueInfo2 {
22503    pub s_type: StructureType,
22504    pub p_next: *const c_void,
22505    pub flags: DeviceQueueCreateFlags,
22506    pub queue_family_index: u32,
22507    pub queue_index: u32,
22508}
22509impl ::std::default::Default for DeviceQueueInfo2 {
22510    fn default() -> Self {
22511        Self {
22512            s_type: StructureType::DEVICE_QUEUE_INFO_2,
22513            p_next: ::std::ptr::null(),
22514            flags: DeviceQueueCreateFlags::default(),
22515            queue_family_index: u32::default(),
22516            queue_index: u32::default(),
22517        }
22518    }
22519}
22520impl DeviceQueueInfo2 {
22521    pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> {
22522        DeviceQueueInfo2Builder {
22523            inner: Self::default(),
22524            marker: ::std::marker::PhantomData,
22525        }
22526    }
22527}
22528#[repr(transparent)]
22529pub struct DeviceQueueInfo2Builder<'a> {
22530    inner: DeviceQueueInfo2,
22531    marker: ::std::marker::PhantomData<&'a ()>,
22532}
22533impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> {
22534    type Target = DeviceQueueInfo2;
22535    fn deref(&self) -> &Self::Target {
22536        &self.inner
22537    }
22538}
22539impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> {
22540    fn deref_mut(&mut self) -> &mut Self::Target {
22541        &mut self.inner
22542    }
22543}
22544impl<'a> DeviceQueueInfo2Builder<'a> {
22545    pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
22546        self.inner.flags = flags;
22547        self
22548    }
22549    pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
22550        self.inner.queue_family_index = queue_family_index;
22551        self
22552    }
22553    pub fn queue_index(mut self, queue_index: u32) -> Self {
22554        self.inner.queue_index = queue_index;
22555        self
22556    }
22557    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22558    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22559    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22560    pub fn build(self) -> DeviceQueueInfo2 {
22561        self.inner
22562    }
22563}
22564#[repr(C)]
22565#[cfg_attr(feature = "debug", derive(Debug))]
22566#[derive(Copy, Clone)]
22567#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>"]
22568pub struct PipelineCoverageToColorStateCreateInfoNV {
22569    pub s_type: StructureType,
22570    pub p_next: *const c_void,
22571    pub flags: PipelineCoverageToColorStateCreateFlagsNV,
22572    pub coverage_to_color_enable: Bool32,
22573    pub coverage_to_color_location: u32,
22574}
22575impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV {
22576    fn default() -> Self {
22577        Self {
22578            s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
22579            p_next: ::std::ptr::null(),
22580            flags: PipelineCoverageToColorStateCreateFlagsNV::default(),
22581            coverage_to_color_enable: Bool32::default(),
22582            coverage_to_color_location: u32::default(),
22583        }
22584    }
22585}
22586impl PipelineCoverageToColorStateCreateInfoNV {
22587    pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22588        PipelineCoverageToColorStateCreateInfoNVBuilder {
22589            inner: Self::default(),
22590            marker: ::std::marker::PhantomData,
22591        }
22592    }
22593}
22594#[repr(transparent)]
22595pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22596    inner: PipelineCoverageToColorStateCreateInfoNV,
22597    marker: ::std::marker::PhantomData<&'a ()>,
22598}
22599unsafe impl ExtendsPipelineMultisampleStateCreateInfo
22600    for PipelineCoverageToColorStateCreateInfoNVBuilder<'_>
22601{
22602}
22603unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {}
22604impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22605    type Target = PipelineCoverageToColorStateCreateInfoNV;
22606    fn deref(&self) -> &Self::Target {
22607        &self.inner
22608    }
22609}
22610impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22611    fn deref_mut(&mut self) -> &mut Self::Target {
22612        &mut self.inner
22613    }
22614}
22615impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
22616    pub fn flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self {
22617        self.inner.flags = flags;
22618        self
22619    }
22620    pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self {
22621        self.inner.coverage_to_color_enable = coverage_to_color_enable.into();
22622        self
22623    }
22624    pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self {
22625        self.inner.coverage_to_color_location = coverage_to_color_location;
22626        self
22627    }
22628    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22629    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22630    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22631    pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV {
22632        self.inner
22633    }
22634}
22635#[repr(C)]
22636#[cfg_attr(feature = "debug", derive(Debug))]
22637#[derive(Copy, Clone)]
22638#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>"]
22639pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
22640    pub s_type: StructureType,
22641    pub p_next: *mut c_void,
22642    pub filter_minmax_single_component_formats: Bool32,
22643    pub filter_minmax_image_component_mapping: Bool32,
22644}
22645impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties {
22646    fn default() -> Self {
22647        Self {
22648            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
22649            p_next: ::std::ptr::null_mut(),
22650            filter_minmax_single_component_formats: Bool32::default(),
22651            filter_minmax_image_component_mapping: Bool32::default(),
22652        }
22653    }
22654}
22655impl PhysicalDeviceSamplerFilterMinmaxProperties {
22656    pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22657        PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder {
22658            inner: Self::default(),
22659            marker: ::std::marker::PhantomData,
22660        }
22661    }
22662}
22663#[repr(transparent)]
22664pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22665    inner: PhysicalDeviceSamplerFilterMinmaxProperties,
22666    marker: ::std::marker::PhantomData<&'a ()>,
22667}
22668unsafe impl ExtendsPhysicalDeviceProperties2
22669    for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_>
22670{
22671}
22672unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {}
22673impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22674    type Target = PhysicalDeviceSamplerFilterMinmaxProperties;
22675    fn deref(&self) -> &Self::Target {
22676        &self.inner
22677    }
22678}
22679impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22680    fn deref_mut(&mut self) -> &mut Self::Target {
22681        &mut self.inner
22682    }
22683}
22684impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
22685    pub fn filter_minmax_single_component_formats(
22686        mut self,
22687        filter_minmax_single_component_formats: bool,
22688    ) -> Self {
22689        self.inner.filter_minmax_single_component_formats =
22690            filter_minmax_single_component_formats.into();
22691        self
22692    }
22693    pub fn filter_minmax_image_component_mapping(
22694        mut self,
22695        filter_minmax_image_component_mapping: bool,
22696    ) -> Self {
22697        self.inner.filter_minmax_image_component_mapping =
22698            filter_minmax_image_component_mapping.into();
22699        self
22700    }
22701    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22702    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22703    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22704    pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties {
22705        self.inner
22706    }
22707}
22708#[repr(C)]
22709#[cfg_attr(feature = "debug", derive(Debug))]
22710#[derive(Copy, Clone, Default)]
22711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationEXT.html>"]
22712pub struct SampleLocationEXT {
22713    pub x: f32,
22714    pub y: f32,
22715}
22716impl SampleLocationEXT {
22717    pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> {
22718        SampleLocationEXTBuilder {
22719            inner: Self::default(),
22720            marker: ::std::marker::PhantomData,
22721        }
22722    }
22723}
22724#[repr(transparent)]
22725pub struct SampleLocationEXTBuilder<'a> {
22726    inner: SampleLocationEXT,
22727    marker: ::std::marker::PhantomData<&'a ()>,
22728}
22729impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> {
22730    type Target = SampleLocationEXT;
22731    fn deref(&self) -> &Self::Target {
22732        &self.inner
22733    }
22734}
22735impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> {
22736    fn deref_mut(&mut self) -> &mut Self::Target {
22737        &mut self.inner
22738    }
22739}
22740impl<'a> SampleLocationEXTBuilder<'a> {
22741    pub fn x(mut self, x: f32) -> Self {
22742        self.inner.x = x;
22743        self
22744    }
22745    pub fn y(mut self, y: f32) -> Self {
22746        self.inner.y = y;
22747        self
22748    }
22749    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22750    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22751    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22752    pub fn build(self) -> SampleLocationEXT {
22753        self.inner
22754    }
22755}
22756#[repr(C)]
22757#[cfg_attr(feature = "debug", derive(Debug))]
22758#[derive(Copy, Clone)]
22759#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationsInfoEXT.html>"]
22760pub struct SampleLocationsInfoEXT {
22761    pub s_type: StructureType,
22762    pub p_next: *const c_void,
22763    pub sample_locations_per_pixel: SampleCountFlags,
22764    pub sample_location_grid_size: Extent2D,
22765    pub sample_locations_count: u32,
22766    pub p_sample_locations: *const SampleLocationEXT,
22767}
22768impl ::std::default::Default for SampleLocationsInfoEXT {
22769    fn default() -> Self {
22770        Self {
22771            s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT,
22772            p_next: ::std::ptr::null(),
22773            sample_locations_per_pixel: SampleCountFlags::default(),
22774            sample_location_grid_size: Extent2D::default(),
22775            sample_locations_count: u32::default(),
22776            p_sample_locations: ::std::ptr::null(),
22777        }
22778    }
22779}
22780impl SampleLocationsInfoEXT {
22781    pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> {
22782        SampleLocationsInfoEXTBuilder {
22783            inner: Self::default(),
22784            marker: ::std::marker::PhantomData,
22785        }
22786    }
22787}
22788#[repr(transparent)]
22789pub struct SampleLocationsInfoEXTBuilder<'a> {
22790    inner: SampleLocationsInfoEXT,
22791    marker: ::std::marker::PhantomData<&'a ()>,
22792}
22793unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {}
22794unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {}
22795unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXTBuilder<'_> {}
22796unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT {}
22797impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> {
22798    type Target = SampleLocationsInfoEXT;
22799    fn deref(&self) -> &Self::Target {
22800        &self.inner
22801    }
22802}
22803impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> {
22804    fn deref_mut(&mut self) -> &mut Self::Target {
22805        &mut self.inner
22806    }
22807}
22808impl<'a> SampleLocationsInfoEXTBuilder<'a> {
22809    pub fn sample_locations_per_pixel(
22810        mut self,
22811        sample_locations_per_pixel: SampleCountFlags,
22812    ) -> Self {
22813        self.inner.sample_locations_per_pixel = sample_locations_per_pixel;
22814        self
22815    }
22816    pub fn sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self {
22817        self.inner.sample_location_grid_size = sample_location_grid_size;
22818        self
22819    }
22820    pub fn sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self {
22821        self.inner.sample_locations_count = sample_locations.len() as _;
22822        self.inner.p_sample_locations = sample_locations.as_ptr();
22823        self
22824    }
22825    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22826    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22827    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22828    pub fn build(self) -> SampleLocationsInfoEXT {
22829        self.inner
22830    }
22831}
22832#[repr(C)]
22833#[cfg_attr(feature = "debug", derive(Debug))]
22834#[derive(Copy, Clone, Default)]
22835#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleLocationsEXT.html>"]
22836pub struct AttachmentSampleLocationsEXT {
22837    pub attachment_index: u32,
22838    pub sample_locations_info: SampleLocationsInfoEXT,
22839}
22840impl AttachmentSampleLocationsEXT {
22841    pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> {
22842        AttachmentSampleLocationsEXTBuilder {
22843            inner: Self::default(),
22844            marker: ::std::marker::PhantomData,
22845        }
22846    }
22847}
22848#[repr(transparent)]
22849pub struct AttachmentSampleLocationsEXTBuilder<'a> {
22850    inner: AttachmentSampleLocationsEXT,
22851    marker: ::std::marker::PhantomData<&'a ()>,
22852}
22853impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> {
22854    type Target = AttachmentSampleLocationsEXT;
22855    fn deref(&self) -> &Self::Target {
22856        &self.inner
22857    }
22858}
22859impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> {
22860    fn deref_mut(&mut self) -> &mut Self::Target {
22861        &mut self.inner
22862    }
22863}
22864impl<'a> AttachmentSampleLocationsEXTBuilder<'a> {
22865    pub fn attachment_index(mut self, attachment_index: u32) -> Self {
22866        self.inner.attachment_index = attachment_index;
22867        self
22868    }
22869    pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
22870        self.inner.sample_locations_info = sample_locations_info;
22871        self
22872    }
22873    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22874    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22875    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22876    pub fn build(self) -> AttachmentSampleLocationsEXT {
22877        self.inner
22878    }
22879}
22880#[repr(C)]
22881#[cfg_attr(feature = "debug", derive(Debug))]
22882#[derive(Copy, Clone, Default)]
22883#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassSampleLocationsEXT.html>"]
22884pub struct SubpassSampleLocationsEXT {
22885    pub subpass_index: u32,
22886    pub sample_locations_info: SampleLocationsInfoEXT,
22887}
22888impl SubpassSampleLocationsEXT {
22889    pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> {
22890        SubpassSampleLocationsEXTBuilder {
22891            inner: Self::default(),
22892            marker: ::std::marker::PhantomData,
22893        }
22894    }
22895}
22896#[repr(transparent)]
22897pub struct SubpassSampleLocationsEXTBuilder<'a> {
22898    inner: SubpassSampleLocationsEXT,
22899    marker: ::std::marker::PhantomData<&'a ()>,
22900}
22901impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> {
22902    type Target = SubpassSampleLocationsEXT;
22903    fn deref(&self) -> &Self::Target {
22904        &self.inner
22905    }
22906}
22907impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> {
22908    fn deref_mut(&mut self) -> &mut Self::Target {
22909        &mut self.inner
22910    }
22911}
22912impl<'a> SubpassSampleLocationsEXTBuilder<'a> {
22913    pub fn subpass_index(mut self, subpass_index: u32) -> Self {
22914        self.inner.subpass_index = subpass_index;
22915        self
22916    }
22917    pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
22918        self.inner.sample_locations_info = sample_locations_info;
22919        self
22920    }
22921    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22922    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22923    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
22924    pub fn build(self) -> SubpassSampleLocationsEXT {
22925        self.inner
22926    }
22927}
22928#[repr(C)]
22929#[cfg_attr(feature = "debug", derive(Debug))]
22930#[derive(Copy, Clone)]
22931#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>"]
22932pub struct RenderPassSampleLocationsBeginInfoEXT {
22933    pub s_type: StructureType,
22934    pub p_next: *const c_void,
22935    pub attachment_initial_sample_locations_count: u32,
22936    pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT,
22937    pub post_subpass_sample_locations_count: u32,
22938    pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT,
22939}
22940impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT {
22941    fn default() -> Self {
22942        Self {
22943            s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
22944            p_next: ::std::ptr::null(),
22945            attachment_initial_sample_locations_count: u32::default(),
22946            p_attachment_initial_sample_locations: ::std::ptr::null(),
22947            post_subpass_sample_locations_count: u32::default(),
22948            p_post_subpass_sample_locations: ::std::ptr::null(),
22949        }
22950    }
22951}
22952impl RenderPassSampleLocationsBeginInfoEXT {
22953    pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22954        RenderPassSampleLocationsBeginInfoEXTBuilder {
22955            inner: Self::default(),
22956            marker: ::std::marker::PhantomData,
22957        }
22958    }
22959}
22960#[repr(transparent)]
22961pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22962    inner: RenderPassSampleLocationsBeginInfoEXT,
22963    marker: ::std::marker::PhantomData<&'a ()>,
22964}
22965unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {}
22966unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {}
22967impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22968    type Target = RenderPassSampleLocationsBeginInfoEXT;
22969    fn deref(&self) -> &Self::Target {
22970        &self.inner
22971    }
22972}
22973impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22974    fn deref_mut(&mut self) -> &mut Self::Target {
22975        &mut self.inner
22976    }
22977}
22978impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
22979    pub fn attachment_initial_sample_locations(
22980        mut self,
22981        attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT],
22982    ) -> Self {
22983        self.inner.attachment_initial_sample_locations_count =
22984            attachment_initial_sample_locations.len() as _;
22985        self.inner.p_attachment_initial_sample_locations =
22986            attachment_initial_sample_locations.as_ptr();
22987        self
22988    }
22989    pub fn post_subpass_sample_locations(
22990        mut self,
22991        post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT],
22992    ) -> Self {
22993        self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _;
22994        self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr();
22995        self
22996    }
22997    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22998    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22999    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23000    pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT {
23001        self.inner
23002    }
23003}
23004#[repr(C)]
23005#[cfg_attr(feature = "debug", derive(Debug))]
23006#[derive(Copy, Clone)]
23007#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>"]
23008pub struct PipelineSampleLocationsStateCreateInfoEXT {
23009    pub s_type: StructureType,
23010    pub p_next: *const c_void,
23011    pub sample_locations_enable: Bool32,
23012    pub sample_locations_info: SampleLocationsInfoEXT,
23013}
23014impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT {
23015    fn default() -> Self {
23016        Self {
23017            s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
23018            p_next: ::std::ptr::null(),
23019            sample_locations_enable: Bool32::default(),
23020            sample_locations_info: SampleLocationsInfoEXT::default(),
23021        }
23022    }
23023}
23024impl PipelineSampleLocationsStateCreateInfoEXT {
23025    pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23026        PipelineSampleLocationsStateCreateInfoEXTBuilder {
23027            inner: Self::default(),
23028            marker: ::std::marker::PhantomData,
23029        }
23030    }
23031}
23032#[repr(transparent)]
23033pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23034    inner: PipelineSampleLocationsStateCreateInfoEXT,
23035    marker: ::std::marker::PhantomData<&'a ()>,
23036}
23037unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23038    for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_>
23039{
23040}
23041unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23042    for PipelineSampleLocationsStateCreateInfoEXT
23043{
23044}
23045impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23046    type Target = PipelineSampleLocationsStateCreateInfoEXT;
23047    fn deref(&self) -> &Self::Target {
23048        &self.inner
23049    }
23050}
23051impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23052    fn deref_mut(&mut self) -> &mut Self::Target {
23053        &mut self.inner
23054    }
23055}
23056impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
23057    pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self {
23058        self.inner.sample_locations_enable = sample_locations_enable.into();
23059        self
23060    }
23061    pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
23062        self.inner.sample_locations_info = sample_locations_info;
23063        self
23064    }
23065    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23066    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23067    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23068    pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT {
23069        self.inner
23070    }
23071}
23072#[repr(C)]
23073#[cfg_attr(feature = "debug", derive(Debug))]
23074#[derive(Copy, Clone)]
23075#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>"]
23076pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
23077    pub s_type: StructureType,
23078    pub p_next: *mut c_void,
23079    pub sample_location_sample_counts: SampleCountFlags,
23080    pub max_sample_location_grid_size: Extent2D,
23081    pub sample_location_coordinate_range: [f32; 2],
23082    pub sample_location_sub_pixel_bits: u32,
23083    pub variable_sample_locations: Bool32,
23084}
23085impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT {
23086    fn default() -> Self {
23087        Self {
23088            s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
23089            p_next: ::std::ptr::null_mut(),
23090            sample_location_sample_counts: SampleCountFlags::default(),
23091            max_sample_location_grid_size: Extent2D::default(),
23092            sample_location_coordinate_range: unsafe { ::std::mem::zeroed() },
23093            sample_location_sub_pixel_bits: u32::default(),
23094            variable_sample_locations: Bool32::default(),
23095        }
23096    }
23097}
23098impl PhysicalDeviceSampleLocationsPropertiesEXT {
23099    pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23100        PhysicalDeviceSampleLocationsPropertiesEXTBuilder {
23101            inner: Self::default(),
23102            marker: ::std::marker::PhantomData,
23103        }
23104    }
23105}
23106#[repr(transparent)]
23107pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23108    inner: PhysicalDeviceSampleLocationsPropertiesEXT,
23109    marker: ::std::marker::PhantomData<&'a ()>,
23110}
23111unsafe impl ExtendsPhysicalDeviceProperties2
23112    for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_>
23113{
23114}
23115unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {}
23116impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23117    type Target = PhysicalDeviceSampleLocationsPropertiesEXT;
23118    fn deref(&self) -> &Self::Target {
23119        &self.inner
23120    }
23121}
23122impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23123    fn deref_mut(&mut self) -> &mut Self::Target {
23124        &mut self.inner
23125    }
23126}
23127impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
23128    pub fn sample_location_sample_counts(
23129        mut self,
23130        sample_location_sample_counts: SampleCountFlags,
23131    ) -> Self {
23132        self.inner.sample_location_sample_counts = sample_location_sample_counts;
23133        self
23134    }
23135    pub fn max_sample_location_grid_size(
23136        mut self,
23137        max_sample_location_grid_size: Extent2D,
23138    ) -> Self {
23139        self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
23140        self
23141    }
23142    pub fn sample_location_coordinate_range(
23143        mut self,
23144        sample_location_coordinate_range: [f32; 2],
23145    ) -> Self {
23146        self.inner.sample_location_coordinate_range = sample_location_coordinate_range;
23147        self
23148    }
23149    pub fn sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self {
23150        self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits;
23151        self
23152    }
23153    pub fn variable_sample_locations(mut self, variable_sample_locations: bool) -> Self {
23154        self.inner.variable_sample_locations = variable_sample_locations.into();
23155        self
23156    }
23157    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23158    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23159    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23160    pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT {
23161        self.inner
23162    }
23163}
23164#[repr(C)]
23165#[cfg_attr(feature = "debug", derive(Debug))]
23166#[derive(Copy, Clone)]
23167#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisamplePropertiesEXT.html>"]
23168pub struct MultisamplePropertiesEXT {
23169    pub s_type: StructureType,
23170    pub p_next: *mut c_void,
23171    pub max_sample_location_grid_size: Extent2D,
23172}
23173impl ::std::default::Default for MultisamplePropertiesEXT {
23174    fn default() -> Self {
23175        Self {
23176            s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT,
23177            p_next: ::std::ptr::null_mut(),
23178            max_sample_location_grid_size: Extent2D::default(),
23179        }
23180    }
23181}
23182impl MultisamplePropertiesEXT {
23183    pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> {
23184        MultisamplePropertiesEXTBuilder {
23185            inner: Self::default(),
23186            marker: ::std::marker::PhantomData,
23187        }
23188    }
23189}
23190#[repr(transparent)]
23191pub struct MultisamplePropertiesEXTBuilder<'a> {
23192    inner: MultisamplePropertiesEXT,
23193    marker: ::std::marker::PhantomData<&'a ()>,
23194}
23195impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> {
23196    type Target = MultisamplePropertiesEXT;
23197    fn deref(&self) -> &Self::Target {
23198        &self.inner
23199    }
23200}
23201impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> {
23202    fn deref_mut(&mut self) -> &mut Self::Target {
23203        &mut self.inner
23204    }
23205}
23206impl<'a> MultisamplePropertiesEXTBuilder<'a> {
23207    pub fn max_sample_location_grid_size(
23208        mut self,
23209        max_sample_location_grid_size: Extent2D,
23210    ) -> Self {
23211        self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
23212        self
23213    }
23214    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23215    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23216    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23217    pub fn build(self) -> MultisamplePropertiesEXT {
23218        self.inner
23219    }
23220}
23221#[repr(C)]
23222#[cfg_attr(feature = "debug", derive(Debug))]
23223#[derive(Copy, Clone)]
23224#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerReductionModeCreateInfo.html>"]
23225pub struct SamplerReductionModeCreateInfo {
23226    pub s_type: StructureType,
23227    pub p_next: *const c_void,
23228    pub reduction_mode: SamplerReductionMode,
23229}
23230impl ::std::default::Default for SamplerReductionModeCreateInfo {
23231    fn default() -> Self {
23232        Self {
23233            s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO,
23234            p_next: ::std::ptr::null(),
23235            reduction_mode: SamplerReductionMode::default(),
23236        }
23237    }
23238}
23239impl SamplerReductionModeCreateInfo {
23240    pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> {
23241        SamplerReductionModeCreateInfoBuilder {
23242            inner: Self::default(),
23243            marker: ::std::marker::PhantomData,
23244        }
23245    }
23246}
23247#[repr(transparent)]
23248pub struct SamplerReductionModeCreateInfoBuilder<'a> {
23249    inner: SamplerReductionModeCreateInfo,
23250    marker: ::std::marker::PhantomData<&'a ()>,
23251}
23252unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {}
23253unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {}
23254impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> {
23255    type Target = SamplerReductionModeCreateInfo;
23256    fn deref(&self) -> &Self::Target {
23257        &self.inner
23258    }
23259}
23260impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> {
23261    fn deref_mut(&mut self) -> &mut Self::Target {
23262        &mut self.inner
23263    }
23264}
23265impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
23266    pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self {
23267        self.inner.reduction_mode = reduction_mode;
23268        self
23269    }
23270    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23271    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23272    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23273    pub fn build(self) -> SamplerReductionModeCreateInfo {
23274        self.inner
23275    }
23276}
23277#[repr(C)]
23278#[cfg_attr(feature = "debug", derive(Debug))]
23279#[derive(Copy, Clone)]
23280#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>"]
23281pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23282    pub s_type: StructureType,
23283    pub p_next: *mut c_void,
23284    pub advanced_blend_coherent_operations: Bool32,
23285}
23286impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23287    fn default() -> Self {
23288        Self {
23289            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
23290            p_next: ::std::ptr::null_mut(),
23291            advanced_blend_coherent_operations: Bool32::default(),
23292        }
23293    }
23294}
23295impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23296    pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23297        PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder {
23298            inner: Self::default(),
23299            marker: ::std::marker::PhantomData,
23300        }
23301    }
23302}
23303#[repr(transparent)]
23304pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23305    inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
23306    marker: ::std::marker::PhantomData<&'a ()>,
23307}
23308unsafe impl ExtendsPhysicalDeviceFeatures2
23309    for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_>
23310{
23311}
23312unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
23313unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {}
23314unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
23315impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23316    type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
23317    fn deref(&self) -> &Self::Target {
23318        &self.inner
23319    }
23320}
23321impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23322    fn deref_mut(&mut self) -> &mut Self::Target {
23323        &mut self.inner
23324    }
23325}
23326impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
23327    pub fn advanced_blend_coherent_operations(
23328        mut self,
23329        advanced_blend_coherent_operations: bool,
23330    ) -> Self {
23331        self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into();
23332        self
23333    }
23334    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23335    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23336    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23337    pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
23338        self.inner
23339    }
23340}
23341#[repr(C)]
23342#[cfg_attr(feature = "debug", derive(Debug))]
23343#[derive(Copy, Clone)]
23344#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html>"]
23345pub struct PhysicalDeviceMultiDrawFeaturesEXT {
23346    pub s_type: StructureType,
23347    pub p_next: *mut c_void,
23348    pub multi_draw: Bool32,
23349}
23350impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT {
23351    fn default() -> Self {
23352        Self {
23353            s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT,
23354            p_next: ::std::ptr::null_mut(),
23355            multi_draw: Bool32::default(),
23356        }
23357    }
23358}
23359impl PhysicalDeviceMultiDrawFeaturesEXT {
23360    pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23361        PhysicalDeviceMultiDrawFeaturesEXTBuilder {
23362            inner: Self::default(),
23363            marker: ::std::marker::PhantomData,
23364        }
23365    }
23366}
23367#[repr(transparent)]
23368pub struct PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23369    inner: PhysicalDeviceMultiDrawFeaturesEXT,
23370    marker: ::std::marker::PhantomData<&'a ()>,
23371}
23372unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {}
23373unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT {}
23374unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {}
23375unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT {}
23376impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23377    type Target = PhysicalDeviceMultiDrawFeaturesEXT;
23378    fn deref(&self) -> &Self::Target {
23379        &self.inner
23380    }
23381}
23382impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23383    fn deref_mut(&mut self) -> &mut Self::Target {
23384        &mut self.inner
23385    }
23386}
23387impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
23388    pub fn multi_draw(mut self, multi_draw: bool) -> Self {
23389        self.inner.multi_draw = multi_draw.into();
23390        self
23391    }
23392    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23393    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23394    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23395    pub fn build(self) -> PhysicalDeviceMultiDrawFeaturesEXT {
23396        self.inner
23397    }
23398}
23399#[repr(C)]
23400#[cfg_attr(feature = "debug", derive(Debug))]
23401#[derive(Copy, Clone)]
23402#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>"]
23403pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23404    pub s_type: StructureType,
23405    pub p_next: *mut c_void,
23406    pub advanced_blend_max_color_attachments: u32,
23407    pub advanced_blend_independent_blend: Bool32,
23408    pub advanced_blend_non_premultiplied_src_color: Bool32,
23409    pub advanced_blend_non_premultiplied_dst_color: Bool32,
23410    pub advanced_blend_correlated_overlap: Bool32,
23411    pub advanced_blend_all_operations: Bool32,
23412}
23413impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23414    fn default() -> Self {
23415        Self {
23416            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
23417            p_next: ::std::ptr::null_mut(),
23418            advanced_blend_max_color_attachments: u32::default(),
23419            advanced_blend_independent_blend: Bool32::default(),
23420            advanced_blend_non_premultiplied_src_color: Bool32::default(),
23421            advanced_blend_non_premultiplied_dst_color: Bool32::default(),
23422            advanced_blend_correlated_overlap: Bool32::default(),
23423            advanced_blend_all_operations: Bool32::default(),
23424        }
23425    }
23426}
23427impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23428    pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23429        PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder {
23430            inner: Self::default(),
23431            marker: ::std::marker::PhantomData,
23432        }
23433    }
23434}
23435#[repr(transparent)]
23436pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23437    inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
23438    marker: ::std::marker::PhantomData<&'a ()>,
23439}
23440unsafe impl ExtendsPhysicalDeviceProperties2
23441    for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_>
23442{
23443}
23444unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {}
23445impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23446    type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
23447    fn deref(&self) -> &Self::Target {
23448        &self.inner
23449    }
23450}
23451impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23452    fn deref_mut(&mut self) -> &mut Self::Target {
23453        &mut self.inner
23454    }
23455}
23456impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
23457    pub fn advanced_blend_max_color_attachments(
23458        mut self,
23459        advanced_blend_max_color_attachments: u32,
23460    ) -> Self {
23461        self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments;
23462        self
23463    }
23464    pub fn advanced_blend_independent_blend(
23465        mut self,
23466        advanced_blend_independent_blend: bool,
23467    ) -> Self {
23468        self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into();
23469        self
23470    }
23471    pub fn advanced_blend_non_premultiplied_src_color(
23472        mut self,
23473        advanced_blend_non_premultiplied_src_color: bool,
23474    ) -> Self {
23475        self.inner.advanced_blend_non_premultiplied_src_color =
23476            advanced_blend_non_premultiplied_src_color.into();
23477        self
23478    }
23479    pub fn advanced_blend_non_premultiplied_dst_color(
23480        mut self,
23481        advanced_blend_non_premultiplied_dst_color: bool,
23482    ) -> Self {
23483        self.inner.advanced_blend_non_premultiplied_dst_color =
23484            advanced_blend_non_premultiplied_dst_color.into();
23485        self
23486    }
23487    pub fn advanced_blend_correlated_overlap(
23488        mut self,
23489        advanced_blend_correlated_overlap: bool,
23490    ) -> Self {
23491        self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into();
23492        self
23493    }
23494    pub fn advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self {
23495        self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into();
23496        self
23497    }
23498    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23499    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23500    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23501    pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
23502        self.inner
23503    }
23504}
23505#[repr(C)]
23506#[cfg_attr(feature = "debug", derive(Debug))]
23507#[derive(Copy, Clone)]
23508#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>"]
23509pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
23510    pub s_type: StructureType,
23511    pub p_next: *const c_void,
23512    pub src_premultiplied: Bool32,
23513    pub dst_premultiplied: Bool32,
23514    pub blend_overlap: BlendOverlapEXT,
23515}
23516impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
23517    fn default() -> Self {
23518        Self {
23519            s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
23520            p_next: ::std::ptr::null(),
23521            src_premultiplied: Bool32::default(),
23522            dst_premultiplied: Bool32::default(),
23523            blend_overlap: BlendOverlapEXT::default(),
23524        }
23525    }
23526}
23527impl PipelineColorBlendAdvancedStateCreateInfoEXT {
23528    pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23529        PipelineColorBlendAdvancedStateCreateInfoEXTBuilder {
23530            inner: Self::default(),
23531            marker: ::std::marker::PhantomData,
23532        }
23533    }
23534}
23535#[repr(transparent)]
23536pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23537    inner: PipelineColorBlendAdvancedStateCreateInfoEXT,
23538    marker: ::std::marker::PhantomData<&'a ()>,
23539}
23540unsafe impl ExtendsPipelineColorBlendStateCreateInfo
23541    for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_>
23542{
23543}
23544unsafe impl ExtendsPipelineColorBlendStateCreateInfo
23545    for PipelineColorBlendAdvancedStateCreateInfoEXT
23546{
23547}
23548impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23549    type Target = PipelineColorBlendAdvancedStateCreateInfoEXT;
23550    fn deref(&self) -> &Self::Target {
23551        &self.inner
23552    }
23553}
23554impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23555    fn deref_mut(&mut self) -> &mut Self::Target {
23556        &mut self.inner
23557    }
23558}
23559impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
23560    pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self {
23561        self.inner.src_premultiplied = src_premultiplied.into();
23562        self
23563    }
23564    pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self {
23565        self.inner.dst_premultiplied = dst_premultiplied.into();
23566        self
23567    }
23568    pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self {
23569        self.inner.blend_overlap = blend_overlap;
23570        self
23571    }
23572    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23573    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23574    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23575    pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT {
23576        self.inner
23577    }
23578}
23579#[repr(C)]
23580#[cfg_attr(feature = "debug", derive(Debug))]
23581#[derive(Copy, Clone)]
23582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeatures.html>"]
23583pub struct PhysicalDeviceInlineUniformBlockFeatures {
23584    pub s_type: StructureType,
23585    pub p_next: *mut c_void,
23586    pub inline_uniform_block: Bool32,
23587    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
23588}
23589impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures {
23590    fn default() -> Self {
23591        Self {
23592            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES,
23593            p_next: ::std::ptr::null_mut(),
23594            inline_uniform_block: Bool32::default(),
23595            descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
23596        }
23597    }
23598}
23599impl PhysicalDeviceInlineUniformBlockFeatures {
23600    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23601        PhysicalDeviceInlineUniformBlockFeaturesBuilder {
23602            inner: Self::default(),
23603            marker: ::std::marker::PhantomData,
23604        }
23605    }
23606}
23607#[repr(transparent)]
23608pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23609    inner: PhysicalDeviceInlineUniformBlockFeatures,
23610    marker: ::std::marker::PhantomData<&'a ()>,
23611}
23612unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
23613unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures {}
23614unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
23615unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures {}
23616impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23617    type Target = PhysicalDeviceInlineUniformBlockFeatures;
23618    fn deref(&self) -> &Self::Target {
23619        &self.inner
23620    }
23621}
23622impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23623    fn deref_mut(&mut self) -> &mut Self::Target {
23624        &mut self.inner
23625    }
23626}
23627impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
23628    pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
23629        self.inner.inline_uniform_block = inline_uniform_block.into();
23630        self
23631    }
23632    pub fn descriptor_binding_inline_uniform_block_update_after_bind(
23633        mut self,
23634        descriptor_binding_inline_uniform_block_update_after_bind: bool,
23635    ) -> Self {
23636        self.inner
23637            .descriptor_binding_inline_uniform_block_update_after_bind =
23638            descriptor_binding_inline_uniform_block_update_after_bind.into();
23639        self
23640    }
23641    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23642    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23643    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23644    pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeatures {
23645        self.inner
23646    }
23647}
23648#[repr(C)]
23649#[cfg_attr(feature = "debug", derive(Debug))]
23650#[derive(Copy, Clone)]
23651#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockProperties.html>"]
23652pub struct PhysicalDeviceInlineUniformBlockProperties {
23653    pub s_type: StructureType,
23654    pub p_next: *mut c_void,
23655    pub max_inline_uniform_block_size: u32,
23656    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
23657    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
23658    pub max_descriptor_set_inline_uniform_blocks: u32,
23659    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
23660}
23661impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties {
23662    fn default() -> Self {
23663        Self {
23664            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES,
23665            p_next: ::std::ptr::null_mut(),
23666            max_inline_uniform_block_size: u32::default(),
23667            max_per_stage_descriptor_inline_uniform_blocks: u32::default(),
23668            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(),
23669            max_descriptor_set_inline_uniform_blocks: u32::default(),
23670            max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(),
23671        }
23672    }
23673}
23674impl PhysicalDeviceInlineUniformBlockProperties {
23675    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23676        PhysicalDeviceInlineUniformBlockPropertiesBuilder {
23677            inner: Self::default(),
23678            marker: ::std::marker::PhantomData,
23679        }
23680    }
23681}
23682#[repr(transparent)]
23683pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23684    inner: PhysicalDeviceInlineUniformBlockProperties,
23685    marker: ::std::marker::PhantomData<&'a ()>,
23686}
23687unsafe impl ExtendsPhysicalDeviceProperties2
23688    for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'_>
23689{
23690}
23691unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties {}
23692impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23693    type Target = PhysicalDeviceInlineUniformBlockProperties;
23694    fn deref(&self) -> &Self::Target {
23695        &self.inner
23696    }
23697}
23698impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23699    fn deref_mut(&mut self) -> &mut Self::Target {
23700        &mut self.inner
23701    }
23702}
23703impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
23704    pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
23705        self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
23706        self
23707    }
23708    pub fn max_per_stage_descriptor_inline_uniform_blocks(
23709        mut self,
23710        max_per_stage_descriptor_inline_uniform_blocks: u32,
23711    ) -> Self {
23712        self.inner.max_per_stage_descriptor_inline_uniform_blocks =
23713            max_per_stage_descriptor_inline_uniform_blocks;
23714        self
23715    }
23716    pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
23717        mut self,
23718        max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
23719    ) -> Self {
23720        self.inner
23721            .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
23722            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
23723        self
23724    }
23725    pub fn max_descriptor_set_inline_uniform_blocks(
23726        mut self,
23727        max_descriptor_set_inline_uniform_blocks: u32,
23728    ) -> Self {
23729        self.inner.max_descriptor_set_inline_uniform_blocks =
23730            max_descriptor_set_inline_uniform_blocks;
23731        self
23732    }
23733    pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
23734        mut self,
23735        max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
23736    ) -> Self {
23737        self.inner
23738            .max_descriptor_set_update_after_bind_inline_uniform_blocks =
23739            max_descriptor_set_update_after_bind_inline_uniform_blocks;
23740        self
23741    }
23742    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23743    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23744    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23745    pub fn build(self) -> PhysicalDeviceInlineUniformBlockProperties {
23746        self.inner
23747    }
23748}
23749#[repr(C)]
23750#[cfg_attr(feature = "debug", derive(Debug))]
23751#[derive(Copy, Clone)]
23752#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetInlineUniformBlock.html>"]
23753pub struct WriteDescriptorSetInlineUniformBlock {
23754    pub s_type: StructureType,
23755    pub p_next: *const c_void,
23756    pub data_size: u32,
23757    pub p_data: *const c_void,
23758}
23759impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock {
23760    fn default() -> Self {
23761        Self {
23762            s_type: StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK,
23763            p_next: ::std::ptr::null(),
23764            data_size: u32::default(),
23765            p_data: ::std::ptr::null(),
23766        }
23767    }
23768}
23769impl WriteDescriptorSetInlineUniformBlock {
23770    pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23771        WriteDescriptorSetInlineUniformBlockBuilder {
23772            inner: Self::default(),
23773            marker: ::std::marker::PhantomData,
23774        }
23775    }
23776}
23777#[repr(transparent)]
23778pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23779    inner: WriteDescriptorSetInlineUniformBlock,
23780    marker: ::std::marker::PhantomData<&'a ()>,
23781}
23782unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockBuilder<'_> {}
23783unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock {}
23784impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23785    type Target = WriteDescriptorSetInlineUniformBlock;
23786    fn deref(&self) -> &Self::Target {
23787        &self.inner
23788    }
23789}
23790impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23791    fn deref_mut(&mut self) -> &mut Self::Target {
23792        &mut self.inner
23793    }
23794}
23795impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
23796    pub fn data(mut self, data: &'a [u8]) -> Self {
23797        self.inner.data_size = data.len() as _;
23798        self.inner.p_data = data.as_ptr() as *const c_void;
23799        self
23800    }
23801    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23802    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23803    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23804    pub fn build(self) -> WriteDescriptorSetInlineUniformBlock {
23805        self.inner
23806    }
23807}
23808#[repr(C)]
23809#[cfg_attr(feature = "debug", derive(Debug))]
23810#[derive(Copy, Clone)]
23811#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html>"]
23812pub struct DescriptorPoolInlineUniformBlockCreateInfo {
23813    pub s_type: StructureType,
23814    pub p_next: *const c_void,
23815    pub max_inline_uniform_block_bindings: u32,
23816}
23817impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo {
23818    fn default() -> Self {
23819        Self {
23820            s_type: StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO,
23821            p_next: ::std::ptr::null(),
23822            max_inline_uniform_block_bindings: u32::default(),
23823        }
23824    }
23825}
23826impl DescriptorPoolInlineUniformBlockCreateInfo {
23827    pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23828        DescriptorPoolInlineUniformBlockCreateInfoBuilder {
23829            inner: Self::default(),
23830            marker: ::std::marker::PhantomData,
23831        }
23832    }
23833}
23834#[repr(transparent)]
23835pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23836    inner: DescriptorPoolInlineUniformBlockCreateInfo,
23837    marker: ::std::marker::PhantomData<&'a ()>,
23838}
23839unsafe impl ExtendsDescriptorPoolCreateInfo
23840    for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'_>
23841{
23842}
23843unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo {}
23844impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23845    type Target = DescriptorPoolInlineUniformBlockCreateInfo;
23846    fn deref(&self) -> &Self::Target {
23847        &self.inner
23848    }
23849}
23850impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23851    fn deref_mut(&mut self) -> &mut Self::Target {
23852        &mut self.inner
23853    }
23854}
23855impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
23856    pub fn max_inline_uniform_block_bindings(
23857        mut self,
23858        max_inline_uniform_block_bindings: u32,
23859    ) -> Self {
23860        self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings;
23861        self
23862    }
23863    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23864    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23865    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23866    pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfo {
23867        self.inner
23868    }
23869}
23870#[repr(C)]
23871#[cfg_attr(feature = "debug", derive(Debug))]
23872#[derive(Copy, Clone)]
23873#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>"]
23874pub struct PipelineCoverageModulationStateCreateInfoNV {
23875    pub s_type: StructureType,
23876    pub p_next: *const c_void,
23877    pub flags: PipelineCoverageModulationStateCreateFlagsNV,
23878    pub coverage_modulation_mode: CoverageModulationModeNV,
23879    pub coverage_modulation_table_enable: Bool32,
23880    pub coverage_modulation_table_count: u32,
23881    pub p_coverage_modulation_table: *const f32,
23882}
23883impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV {
23884    fn default() -> Self {
23885        Self {
23886            s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
23887            p_next: ::std::ptr::null(),
23888            flags: PipelineCoverageModulationStateCreateFlagsNV::default(),
23889            coverage_modulation_mode: CoverageModulationModeNV::default(),
23890            coverage_modulation_table_enable: Bool32::default(),
23891            coverage_modulation_table_count: u32::default(),
23892            p_coverage_modulation_table: ::std::ptr::null(),
23893        }
23894    }
23895}
23896impl PipelineCoverageModulationStateCreateInfoNV {
23897    pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23898        PipelineCoverageModulationStateCreateInfoNVBuilder {
23899            inner: Self::default(),
23900            marker: ::std::marker::PhantomData,
23901        }
23902    }
23903}
23904#[repr(transparent)]
23905pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23906    inner: PipelineCoverageModulationStateCreateInfoNV,
23907    marker: ::std::marker::PhantomData<&'a ()>,
23908}
23909unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23910    for PipelineCoverageModulationStateCreateInfoNVBuilder<'_>
23911{
23912}
23913unsafe impl ExtendsPipelineMultisampleStateCreateInfo
23914    for PipelineCoverageModulationStateCreateInfoNV
23915{
23916}
23917impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23918    type Target = PipelineCoverageModulationStateCreateInfoNV;
23919    fn deref(&self) -> &Self::Target {
23920        &self.inner
23921    }
23922}
23923impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23924    fn deref_mut(&mut self) -> &mut Self::Target {
23925        &mut self.inner
23926    }
23927}
23928impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
23929    pub fn flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self {
23930        self.inner.flags = flags;
23931        self
23932    }
23933    pub fn coverage_modulation_mode(
23934        mut self,
23935        coverage_modulation_mode: CoverageModulationModeNV,
23936    ) -> Self {
23937        self.inner.coverage_modulation_mode = coverage_modulation_mode;
23938        self
23939    }
23940    pub fn coverage_modulation_table_enable(
23941        mut self,
23942        coverage_modulation_table_enable: bool,
23943    ) -> Self {
23944        self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into();
23945        self
23946    }
23947    pub fn coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self {
23948        self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _;
23949        self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr();
23950        self
23951    }
23952    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23953    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23954    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
23955    pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV {
23956        self.inner
23957    }
23958}
23959#[repr(C)]
23960#[cfg_attr(feature = "debug", derive(Debug))]
23961#[derive(Copy, Clone)]
23962#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatListCreateInfo.html>"]
23963pub struct ImageFormatListCreateInfo {
23964    pub s_type: StructureType,
23965    pub p_next: *const c_void,
23966    pub view_format_count: u32,
23967    pub p_view_formats: *const Format,
23968}
23969impl ::std::default::Default for ImageFormatListCreateInfo {
23970    fn default() -> Self {
23971        Self {
23972            s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO,
23973            p_next: ::std::ptr::null(),
23974            view_format_count: u32::default(),
23975            p_view_formats: ::std::ptr::null(),
23976        }
23977    }
23978}
23979impl ImageFormatListCreateInfo {
23980    pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> {
23981        ImageFormatListCreateInfoBuilder {
23982            inner: Self::default(),
23983            marker: ::std::marker::PhantomData,
23984        }
23985    }
23986}
23987#[repr(transparent)]
23988pub struct ImageFormatListCreateInfoBuilder<'a> {
23989    inner: ImageFormatListCreateInfo,
23990    marker: ::std::marker::PhantomData<&'a ()>,
23991}
23992unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {}
23993unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {}
23994unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {}
23995unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {}
23996unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {}
23997unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {}
23998impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> {
23999    type Target = ImageFormatListCreateInfo;
24000    fn deref(&self) -> &Self::Target {
24001        &self.inner
24002    }
24003}
24004impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> {
24005    fn deref_mut(&mut self) -> &mut Self::Target {
24006        &mut self.inner
24007    }
24008}
24009impl<'a> ImageFormatListCreateInfoBuilder<'a> {
24010    pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
24011        self.inner.view_format_count = view_formats.len() as _;
24012        self.inner.p_view_formats = view_formats.as_ptr();
24013        self
24014    }
24015    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24016    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24017    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24018    pub fn build(self) -> ImageFormatListCreateInfo {
24019        self.inner
24020    }
24021}
24022#[repr(C)]
24023#[cfg_attr(feature = "debug", derive(Debug))]
24024#[derive(Copy, Clone)]
24025#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateInfoEXT.html>"]
24026pub struct ValidationCacheCreateInfoEXT {
24027    pub s_type: StructureType,
24028    pub p_next: *const c_void,
24029    pub flags: ValidationCacheCreateFlagsEXT,
24030    pub initial_data_size: usize,
24031    pub p_initial_data: *const c_void,
24032}
24033impl ::std::default::Default for ValidationCacheCreateInfoEXT {
24034    fn default() -> Self {
24035        Self {
24036            s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT,
24037            p_next: ::std::ptr::null(),
24038            flags: ValidationCacheCreateFlagsEXT::default(),
24039            initial_data_size: usize::default(),
24040            p_initial_data: ::std::ptr::null(),
24041        }
24042    }
24043}
24044impl ValidationCacheCreateInfoEXT {
24045    pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> {
24046        ValidationCacheCreateInfoEXTBuilder {
24047            inner: Self::default(),
24048            marker: ::std::marker::PhantomData,
24049        }
24050    }
24051}
24052#[repr(transparent)]
24053pub struct ValidationCacheCreateInfoEXTBuilder<'a> {
24054    inner: ValidationCacheCreateInfoEXT,
24055    marker: ::std::marker::PhantomData<&'a ()>,
24056}
24057impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
24058    type Target = ValidationCacheCreateInfoEXT;
24059    fn deref(&self) -> &Self::Target {
24060        &self.inner
24061    }
24062}
24063impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
24064    fn deref_mut(&mut self) -> &mut Self::Target {
24065        &mut self.inner
24066    }
24067}
24068impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
24069    pub fn flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self {
24070        self.inner.flags = flags;
24071        self
24072    }
24073    pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
24074        self.inner.initial_data_size = initial_data.len();
24075        self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
24076        self
24077    }
24078    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24079    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24080    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24081    pub fn build(self) -> ValidationCacheCreateInfoEXT {
24082        self.inner
24083    }
24084}
24085#[repr(C)]
24086#[cfg_attr(feature = "debug", derive(Debug))]
24087#[derive(Copy, Clone)]
24088#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>"]
24089pub struct ShaderModuleValidationCacheCreateInfoEXT {
24090    pub s_type: StructureType,
24091    pub p_next: *const c_void,
24092    pub validation_cache: ValidationCacheEXT,
24093}
24094impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT {
24095    fn default() -> Self {
24096        Self {
24097            s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
24098            p_next: ::std::ptr::null(),
24099            validation_cache: ValidationCacheEXT::default(),
24100        }
24101    }
24102}
24103impl ShaderModuleValidationCacheCreateInfoEXT {
24104    pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24105        ShaderModuleValidationCacheCreateInfoEXTBuilder {
24106            inner: Self::default(),
24107            marker: ::std::marker::PhantomData,
24108        }
24109    }
24110}
24111#[repr(transparent)]
24112pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24113    inner: ShaderModuleValidationCacheCreateInfoEXT,
24114    marker: ::std::marker::PhantomData<&'a ()>,
24115}
24116unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {}
24117unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
24118impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24119    type Target = ShaderModuleValidationCacheCreateInfoEXT;
24120    fn deref(&self) -> &Self::Target {
24121        &self.inner
24122    }
24123}
24124impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24125    fn deref_mut(&mut self) -> &mut Self::Target {
24126        &mut self.inner
24127    }
24128}
24129impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
24130    pub fn validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self {
24131        self.inner.validation_cache = validation_cache;
24132        self
24133    }
24134    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24135    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24136    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24137    pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT {
24138        self.inner
24139    }
24140}
24141#[repr(C)]
24142#[cfg_attr(feature = "debug", derive(Debug))]
24143#[derive(Copy, Clone)]
24144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html>"]
24145pub struct PhysicalDeviceMaintenance3Properties {
24146    pub s_type: StructureType,
24147    pub p_next: *mut c_void,
24148    pub max_per_set_descriptors: u32,
24149    pub max_memory_allocation_size: DeviceSize,
24150}
24151impl ::std::default::Default for PhysicalDeviceMaintenance3Properties {
24152    fn default() -> Self {
24153        Self {
24154            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
24155            p_next: ::std::ptr::null_mut(),
24156            max_per_set_descriptors: u32::default(),
24157            max_memory_allocation_size: DeviceSize::default(),
24158        }
24159    }
24160}
24161impl PhysicalDeviceMaintenance3Properties {
24162    pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24163        PhysicalDeviceMaintenance3PropertiesBuilder {
24164            inner: Self::default(),
24165            marker: ::std::marker::PhantomData,
24166        }
24167    }
24168}
24169#[repr(transparent)]
24170pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24171    inner: PhysicalDeviceMaintenance3Properties,
24172    marker: ::std::marker::PhantomData<&'a ()>,
24173}
24174unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {}
24175unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {}
24176impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24177    type Target = PhysicalDeviceMaintenance3Properties;
24178    fn deref(&self) -> &Self::Target {
24179        &self.inner
24180    }
24181}
24182impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24183    fn deref_mut(&mut self) -> &mut Self::Target {
24184        &mut self.inner
24185    }
24186}
24187impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
24188    pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
24189        self.inner.max_per_set_descriptors = max_per_set_descriptors;
24190        self
24191    }
24192    pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
24193        self.inner.max_memory_allocation_size = max_memory_allocation_size;
24194        self
24195    }
24196    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24197    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24198    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24199    pub fn build(self) -> PhysicalDeviceMaintenance3Properties {
24200        self.inner
24201    }
24202}
24203#[repr(C)]
24204#[cfg_attr(feature = "debug", derive(Debug))]
24205#[derive(Copy, Clone)]
24206#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Features.html>"]
24207pub struct PhysicalDeviceMaintenance4Features {
24208    pub s_type: StructureType,
24209    pub p_next: *mut c_void,
24210    pub maintenance4: Bool32,
24211}
24212impl ::std::default::Default for PhysicalDeviceMaintenance4Features {
24213    fn default() -> Self {
24214        Self {
24215            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES,
24216            p_next: ::std::ptr::null_mut(),
24217            maintenance4: Bool32::default(),
24218        }
24219    }
24220}
24221impl PhysicalDeviceMaintenance4Features {
24222    pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24223        PhysicalDeviceMaintenance4FeaturesBuilder {
24224            inner: Self::default(),
24225            marker: ::std::marker::PhantomData,
24226        }
24227    }
24228}
24229#[repr(transparent)]
24230pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24231    inner: PhysicalDeviceMaintenance4Features,
24232    marker: ::std::marker::PhantomData<&'a ()>,
24233}
24234unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
24235unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features {}
24236unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
24237unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features {}
24238impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24239    type Target = PhysicalDeviceMaintenance4Features;
24240    fn deref(&self) -> &Self::Target {
24241        &self.inner
24242    }
24243}
24244impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24245    fn deref_mut(&mut self) -> &mut Self::Target {
24246        &mut self.inner
24247    }
24248}
24249impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
24250    pub fn maintenance4(mut self, maintenance4: bool) -> Self {
24251        self.inner.maintenance4 = maintenance4.into();
24252        self
24253    }
24254    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24255    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24256    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24257    pub fn build(self) -> PhysicalDeviceMaintenance4Features {
24258        self.inner
24259    }
24260}
24261#[repr(C)]
24262#[cfg_attr(feature = "debug", derive(Debug))]
24263#[derive(Copy, Clone)]
24264#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Properties.html>"]
24265pub struct PhysicalDeviceMaintenance4Properties {
24266    pub s_type: StructureType,
24267    pub p_next: *mut c_void,
24268    pub max_buffer_size: DeviceSize,
24269}
24270impl ::std::default::Default for PhysicalDeviceMaintenance4Properties {
24271    fn default() -> Self {
24272        Self {
24273            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES,
24274            p_next: ::std::ptr::null_mut(),
24275            max_buffer_size: DeviceSize::default(),
24276        }
24277    }
24278}
24279impl PhysicalDeviceMaintenance4Properties {
24280    pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24281        PhysicalDeviceMaintenance4PropertiesBuilder {
24282            inner: Self::default(),
24283            marker: ::std::marker::PhantomData,
24284        }
24285    }
24286}
24287#[repr(transparent)]
24288pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24289    inner: PhysicalDeviceMaintenance4Properties,
24290    marker: ::std::marker::PhantomData<&'a ()>,
24291}
24292unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesBuilder<'_> {}
24293unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties {}
24294impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24295    type Target = PhysicalDeviceMaintenance4Properties;
24296    fn deref(&self) -> &Self::Target {
24297        &self.inner
24298    }
24299}
24300impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24301    fn deref_mut(&mut self) -> &mut Self::Target {
24302        &mut self.inner
24303    }
24304}
24305impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
24306    pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
24307        self.inner.max_buffer_size = max_buffer_size;
24308        self
24309    }
24310    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24311    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24312    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24313    pub fn build(self) -> PhysicalDeviceMaintenance4Properties {
24314        self.inner
24315    }
24316}
24317#[repr(C)]
24318#[cfg_attr(feature = "debug", derive(Debug))]
24319#[derive(Copy, Clone)]
24320#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutSupport.html>"]
24321pub struct DescriptorSetLayoutSupport {
24322    pub s_type: StructureType,
24323    pub p_next: *mut c_void,
24324    pub supported: Bool32,
24325}
24326impl ::std::default::Default for DescriptorSetLayoutSupport {
24327    fn default() -> Self {
24328        Self {
24329            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT,
24330            p_next: ::std::ptr::null_mut(),
24331            supported: Bool32::default(),
24332        }
24333    }
24334}
24335impl DescriptorSetLayoutSupport {
24336    pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> {
24337        DescriptorSetLayoutSupportBuilder {
24338            inner: Self::default(),
24339            marker: ::std::marker::PhantomData,
24340        }
24341    }
24342}
24343#[repr(transparent)]
24344pub struct DescriptorSetLayoutSupportBuilder<'a> {
24345    inner: DescriptorSetLayoutSupport,
24346    marker: ::std::marker::PhantomData<&'a ()>,
24347}
24348pub unsafe trait ExtendsDescriptorSetLayoutSupport {}
24349impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> {
24350    type Target = DescriptorSetLayoutSupport;
24351    fn deref(&self) -> &Self::Target {
24352        &self.inner
24353    }
24354}
24355impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> {
24356    fn deref_mut(&mut self) -> &mut Self::Target {
24357        &mut self.inner
24358    }
24359}
24360impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
24361    pub fn supported(mut self, supported: bool) -> Self {
24362        self.inner.supported = supported.into();
24363        self
24364    }
24365    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
24366    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
24367    #[doc = r" valid extension structs can be pushed into the chain."]
24368    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
24369    #[doc = r" chain will look like `A -> D -> B -> C`."]
24370    pub fn push_next<T: ExtendsDescriptorSetLayoutSupport>(mut self, next: &'a mut T) -> Self {
24371        unsafe {
24372            let next_ptr = <*mut T>::cast(next);
24373            let last_next = ptr_chain_iter(next).last().unwrap();
24374            (*last_next).p_next = self.inner.p_next as _;
24375            self.inner.p_next = next_ptr;
24376        }
24377        self
24378    }
24379    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24380    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24381    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24382    pub fn build(self) -> DescriptorSetLayoutSupport {
24383        self.inner
24384    }
24385}
24386#[repr(C)]
24387#[cfg_attr(feature = "debug", derive(Debug))]
24388#[derive(Copy, Clone)]
24389#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>"]
24390pub struct PhysicalDeviceShaderDrawParametersFeatures {
24391    pub s_type: StructureType,
24392    pub p_next: *mut c_void,
24393    pub shader_draw_parameters: Bool32,
24394}
24395impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures {
24396    fn default() -> Self {
24397        Self {
24398            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
24399            p_next: ::std::ptr::null_mut(),
24400            shader_draw_parameters: Bool32::default(),
24401        }
24402    }
24403}
24404impl PhysicalDeviceShaderDrawParametersFeatures {
24405    pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24406        PhysicalDeviceShaderDrawParametersFeaturesBuilder {
24407            inner: Self::default(),
24408            marker: ::std::marker::PhantomData,
24409        }
24410    }
24411}
24412#[repr(transparent)]
24413pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24414    inner: PhysicalDeviceShaderDrawParametersFeatures,
24415    marker: ::std::marker::PhantomData<&'a ()>,
24416}
24417unsafe impl ExtendsPhysicalDeviceFeatures2
24418    for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_>
24419{
24420}
24421unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures {}
24422unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {}
24423unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {}
24424impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24425    type Target = PhysicalDeviceShaderDrawParametersFeatures;
24426    fn deref(&self) -> &Self::Target {
24427        &self.inner
24428    }
24429}
24430impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24431    fn deref_mut(&mut self) -> &mut Self::Target {
24432        &mut self.inner
24433    }
24434}
24435impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
24436    pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
24437        self.inner.shader_draw_parameters = shader_draw_parameters.into();
24438        self
24439    }
24440    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24441    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24442    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24443    pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures {
24444        self.inner
24445    }
24446}
24447#[repr(C)]
24448#[cfg_attr(feature = "debug", derive(Debug))]
24449#[derive(Copy, Clone)]
24450#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>"]
24451pub struct PhysicalDeviceShaderFloat16Int8Features {
24452    pub s_type: StructureType,
24453    pub p_next: *mut c_void,
24454    pub shader_float16: Bool32,
24455    pub shader_int8: Bool32,
24456}
24457impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features {
24458    fn default() -> Self {
24459        Self {
24460            s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
24461            p_next: ::std::ptr::null_mut(),
24462            shader_float16: Bool32::default(),
24463            shader_int8: Bool32::default(),
24464        }
24465    }
24466}
24467impl PhysicalDeviceShaderFloat16Int8Features {
24468    pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24469        PhysicalDeviceShaderFloat16Int8FeaturesBuilder {
24470            inner: Self::default(),
24471            marker: ::std::marker::PhantomData,
24472        }
24473    }
24474}
24475#[repr(transparent)]
24476pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24477    inner: PhysicalDeviceShaderFloat16Int8Features,
24478    marker: ::std::marker::PhantomData<&'a ()>,
24479}
24480unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
24481unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features {}
24482unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
24483unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {}
24484impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24485    type Target = PhysicalDeviceShaderFloat16Int8Features;
24486    fn deref(&self) -> &Self::Target {
24487        &self.inner
24488    }
24489}
24490impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24491    fn deref_mut(&mut self) -> &mut Self::Target {
24492        &mut self.inner
24493    }
24494}
24495impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
24496    pub fn shader_float16(mut self, shader_float16: bool) -> Self {
24497        self.inner.shader_float16 = shader_float16.into();
24498        self
24499    }
24500    pub fn shader_int8(mut self, shader_int8: bool) -> Self {
24501        self.inner.shader_int8 = shader_int8.into();
24502        self
24503    }
24504    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24505    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24506    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24507    pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features {
24508        self.inner
24509    }
24510}
24511#[repr(C)]
24512#[cfg_attr(feature = "debug", derive(Debug))]
24513#[derive(Copy, Clone)]
24514#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html>"]
24515pub struct PhysicalDeviceFloatControlsProperties {
24516    pub s_type: StructureType,
24517    pub p_next: *mut c_void,
24518    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
24519    pub rounding_mode_independence: ShaderFloatControlsIndependence,
24520    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
24521    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
24522    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
24523    pub shader_denorm_preserve_float16: Bool32,
24524    pub shader_denorm_preserve_float32: Bool32,
24525    pub shader_denorm_preserve_float64: Bool32,
24526    pub shader_denorm_flush_to_zero_float16: Bool32,
24527    pub shader_denorm_flush_to_zero_float32: Bool32,
24528    pub shader_denorm_flush_to_zero_float64: Bool32,
24529    pub shader_rounding_mode_rte_float16: Bool32,
24530    pub shader_rounding_mode_rte_float32: Bool32,
24531    pub shader_rounding_mode_rte_float64: Bool32,
24532    pub shader_rounding_mode_rtz_float16: Bool32,
24533    pub shader_rounding_mode_rtz_float32: Bool32,
24534    pub shader_rounding_mode_rtz_float64: Bool32,
24535}
24536impl ::std::default::Default for PhysicalDeviceFloatControlsProperties {
24537    fn default() -> Self {
24538        Self {
24539            s_type: StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
24540            p_next: ::std::ptr::null_mut(),
24541            denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
24542            rounding_mode_independence: ShaderFloatControlsIndependence::default(),
24543            shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
24544            shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
24545            shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
24546            shader_denorm_preserve_float16: Bool32::default(),
24547            shader_denorm_preserve_float32: Bool32::default(),
24548            shader_denorm_preserve_float64: Bool32::default(),
24549            shader_denorm_flush_to_zero_float16: Bool32::default(),
24550            shader_denorm_flush_to_zero_float32: Bool32::default(),
24551            shader_denorm_flush_to_zero_float64: Bool32::default(),
24552            shader_rounding_mode_rte_float16: Bool32::default(),
24553            shader_rounding_mode_rte_float32: Bool32::default(),
24554            shader_rounding_mode_rte_float64: Bool32::default(),
24555            shader_rounding_mode_rtz_float16: Bool32::default(),
24556            shader_rounding_mode_rtz_float32: Bool32::default(),
24557            shader_rounding_mode_rtz_float64: Bool32::default(),
24558        }
24559    }
24560}
24561impl PhysicalDeviceFloatControlsProperties {
24562    pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24563        PhysicalDeviceFloatControlsPropertiesBuilder {
24564            inner: Self::default(),
24565            marker: ::std::marker::PhantomData,
24566        }
24567    }
24568}
24569#[repr(transparent)]
24570pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24571    inner: PhysicalDeviceFloatControlsProperties,
24572    marker: ::std::marker::PhantomData<&'a ()>,
24573}
24574unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {}
24575unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {}
24576impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24577    type Target = PhysicalDeviceFloatControlsProperties;
24578    fn deref(&self) -> &Self::Target {
24579        &self.inner
24580    }
24581}
24582impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24583    fn deref_mut(&mut self) -> &mut Self::Target {
24584        &mut self.inner
24585    }
24586}
24587impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
24588    pub fn denorm_behavior_independence(
24589        mut self,
24590        denorm_behavior_independence: ShaderFloatControlsIndependence,
24591    ) -> Self {
24592        self.inner.denorm_behavior_independence = denorm_behavior_independence;
24593        self
24594    }
24595    pub fn rounding_mode_independence(
24596        mut self,
24597        rounding_mode_independence: ShaderFloatControlsIndependence,
24598    ) -> Self {
24599        self.inner.rounding_mode_independence = rounding_mode_independence;
24600        self
24601    }
24602    pub fn shader_signed_zero_inf_nan_preserve_float16(
24603        mut self,
24604        shader_signed_zero_inf_nan_preserve_float16: bool,
24605    ) -> Self {
24606        self.inner.shader_signed_zero_inf_nan_preserve_float16 =
24607            shader_signed_zero_inf_nan_preserve_float16.into();
24608        self
24609    }
24610    pub fn shader_signed_zero_inf_nan_preserve_float32(
24611        mut self,
24612        shader_signed_zero_inf_nan_preserve_float32: bool,
24613    ) -> Self {
24614        self.inner.shader_signed_zero_inf_nan_preserve_float32 =
24615            shader_signed_zero_inf_nan_preserve_float32.into();
24616        self
24617    }
24618    pub fn shader_signed_zero_inf_nan_preserve_float64(
24619        mut self,
24620        shader_signed_zero_inf_nan_preserve_float64: bool,
24621    ) -> Self {
24622        self.inner.shader_signed_zero_inf_nan_preserve_float64 =
24623            shader_signed_zero_inf_nan_preserve_float64.into();
24624        self
24625    }
24626    pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
24627        self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
24628        self
24629    }
24630    pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
24631        self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
24632        self
24633    }
24634    pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
24635        self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
24636        self
24637    }
24638    pub fn shader_denorm_flush_to_zero_float16(
24639        mut self,
24640        shader_denorm_flush_to_zero_float16: bool,
24641    ) -> Self {
24642        self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
24643        self
24644    }
24645    pub fn shader_denorm_flush_to_zero_float32(
24646        mut self,
24647        shader_denorm_flush_to_zero_float32: bool,
24648    ) -> Self {
24649        self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
24650        self
24651    }
24652    pub fn shader_denorm_flush_to_zero_float64(
24653        mut self,
24654        shader_denorm_flush_to_zero_float64: bool,
24655    ) -> Self {
24656        self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
24657        self
24658    }
24659    pub fn shader_rounding_mode_rte_float16(
24660        mut self,
24661        shader_rounding_mode_rte_float16: bool,
24662    ) -> Self {
24663        self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
24664        self
24665    }
24666    pub fn shader_rounding_mode_rte_float32(
24667        mut self,
24668        shader_rounding_mode_rte_float32: bool,
24669    ) -> Self {
24670        self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
24671        self
24672    }
24673    pub fn shader_rounding_mode_rte_float64(
24674        mut self,
24675        shader_rounding_mode_rte_float64: bool,
24676    ) -> Self {
24677        self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
24678        self
24679    }
24680    pub fn shader_rounding_mode_rtz_float16(
24681        mut self,
24682        shader_rounding_mode_rtz_float16: bool,
24683    ) -> Self {
24684        self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
24685        self
24686    }
24687    pub fn shader_rounding_mode_rtz_float32(
24688        mut self,
24689        shader_rounding_mode_rtz_float32: bool,
24690    ) -> Self {
24691        self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
24692        self
24693    }
24694    pub fn shader_rounding_mode_rtz_float64(
24695        mut self,
24696        shader_rounding_mode_rtz_float64: bool,
24697    ) -> Self {
24698        self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
24699        self
24700    }
24701    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24702    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24703    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24704    pub fn build(self) -> PhysicalDeviceFloatControlsProperties {
24705        self.inner
24706    }
24707}
24708#[repr(C)]
24709#[cfg_attr(feature = "debug", derive(Debug))]
24710#[derive(Copy, Clone)]
24711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>"]
24712pub struct PhysicalDeviceHostQueryResetFeatures {
24713    pub s_type: StructureType,
24714    pub p_next: *mut c_void,
24715    pub host_query_reset: Bool32,
24716}
24717impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures {
24718    fn default() -> Self {
24719        Self {
24720            s_type: StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
24721            p_next: ::std::ptr::null_mut(),
24722            host_query_reset: Bool32::default(),
24723        }
24724    }
24725}
24726impl PhysicalDeviceHostQueryResetFeatures {
24727    pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24728        PhysicalDeviceHostQueryResetFeaturesBuilder {
24729            inner: Self::default(),
24730            marker: ::std::marker::PhantomData,
24731        }
24732    }
24733}
24734#[repr(transparent)]
24735pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24736    inner: PhysicalDeviceHostQueryResetFeatures,
24737    marker: ::std::marker::PhantomData<&'a ()>,
24738}
24739unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
24740unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures {}
24741unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
24742unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {}
24743impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24744    type Target = PhysicalDeviceHostQueryResetFeatures;
24745    fn deref(&self) -> &Self::Target {
24746        &self.inner
24747    }
24748}
24749impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24750    fn deref_mut(&mut self) -> &mut Self::Target {
24751        &mut self.inner
24752    }
24753}
24754impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
24755    pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
24756        self.inner.host_query_reset = host_query_reset.into();
24757        self
24758    }
24759    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24760    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24761    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24762    pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures {
24763        self.inner
24764    }
24765}
24766#[repr(C)]
24767#[cfg_attr(feature = "debug", derive(Debug))]
24768#[derive(Copy, Clone, Default)]
24769#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferUsage2ANDROID.html>"]
24770pub struct NativeBufferUsage2ANDROID {
24771    pub consumer: u64,
24772    pub producer: u64,
24773}
24774impl NativeBufferUsage2ANDROID {
24775    pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> {
24776        NativeBufferUsage2ANDROIDBuilder {
24777            inner: Self::default(),
24778            marker: ::std::marker::PhantomData,
24779        }
24780    }
24781}
24782#[repr(transparent)]
24783pub struct NativeBufferUsage2ANDROIDBuilder<'a> {
24784    inner: NativeBufferUsage2ANDROID,
24785    marker: ::std::marker::PhantomData<&'a ()>,
24786}
24787impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> {
24788    type Target = NativeBufferUsage2ANDROID;
24789    fn deref(&self) -> &Self::Target {
24790        &self.inner
24791    }
24792}
24793impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> {
24794    fn deref_mut(&mut self) -> &mut Self::Target {
24795        &mut self.inner
24796    }
24797}
24798impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> {
24799    pub fn consumer(mut self, consumer: u64) -> Self {
24800        self.inner.consumer = consumer;
24801        self
24802    }
24803    pub fn producer(mut self, producer: u64) -> Self {
24804        self.inner.producer = producer;
24805        self
24806    }
24807    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24808    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24809    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24810    pub fn build(self) -> NativeBufferUsage2ANDROID {
24811        self.inner
24812    }
24813}
24814#[repr(C)]
24815#[cfg_attr(feature = "debug", derive(Debug))]
24816#[derive(Copy, Clone)]
24817#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferANDROID.html>"]
24818pub struct NativeBufferANDROID {
24819    pub s_type: StructureType,
24820    pub p_next: *const c_void,
24821    pub handle: *const c_void,
24822    pub stride: c_int,
24823    pub format: c_int,
24824    pub usage: c_int,
24825    pub usage2: NativeBufferUsage2ANDROID,
24826}
24827impl ::std::default::Default for NativeBufferANDROID {
24828    fn default() -> Self {
24829        Self {
24830            s_type: StructureType::NATIVE_BUFFER_ANDROID,
24831            p_next: ::std::ptr::null(),
24832            handle: ::std::ptr::null(),
24833            stride: c_int::default(),
24834            format: c_int::default(),
24835            usage: c_int::default(),
24836            usage2: NativeBufferUsage2ANDROID::default(),
24837        }
24838    }
24839}
24840impl NativeBufferANDROID {
24841    pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> {
24842        NativeBufferANDROIDBuilder {
24843            inner: Self::default(),
24844            marker: ::std::marker::PhantomData,
24845        }
24846    }
24847}
24848#[repr(transparent)]
24849pub struct NativeBufferANDROIDBuilder<'a> {
24850    inner: NativeBufferANDROID,
24851    marker: ::std::marker::PhantomData<&'a ()>,
24852}
24853impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> {
24854    type Target = NativeBufferANDROID;
24855    fn deref(&self) -> &Self::Target {
24856        &self.inner
24857    }
24858}
24859impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> {
24860    fn deref_mut(&mut self) -> &mut Self::Target {
24861        &mut self.inner
24862    }
24863}
24864impl<'a> NativeBufferANDROIDBuilder<'a> {
24865    pub fn handle(mut self, handle: *const c_void) -> Self {
24866        self.inner.handle = handle;
24867        self
24868    }
24869    pub fn stride(mut self, stride: c_int) -> Self {
24870        self.inner.stride = stride;
24871        self
24872    }
24873    pub fn format(mut self, format: c_int) -> Self {
24874        self.inner.format = format;
24875        self
24876    }
24877    pub fn usage(mut self, usage: c_int) -> Self {
24878        self.inner.usage = usage;
24879        self
24880    }
24881    pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self {
24882        self.inner.usage2 = usage2;
24883        self
24884    }
24885    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24886    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24887    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24888    pub fn build(self) -> NativeBufferANDROID {
24889        self.inner
24890    }
24891}
24892#[repr(C)]
24893#[cfg_attr(feature = "debug", derive(Debug))]
24894#[derive(Copy, Clone)]
24895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainImageCreateInfoANDROID.html>"]
24896pub struct SwapchainImageCreateInfoANDROID {
24897    pub s_type: StructureType,
24898    pub p_next: *const c_void,
24899    pub usage: SwapchainImageUsageFlagsANDROID,
24900}
24901impl ::std::default::Default for SwapchainImageCreateInfoANDROID {
24902    fn default() -> Self {
24903        Self {
24904            s_type: StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
24905            p_next: ::std::ptr::null(),
24906            usage: SwapchainImageUsageFlagsANDROID::default(),
24907        }
24908    }
24909}
24910impl SwapchainImageCreateInfoANDROID {
24911    pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
24912        SwapchainImageCreateInfoANDROIDBuilder {
24913            inner: Self::default(),
24914            marker: ::std::marker::PhantomData,
24915        }
24916    }
24917}
24918#[repr(transparent)]
24919pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> {
24920    inner: SwapchainImageCreateInfoANDROID,
24921    marker: ::std::marker::PhantomData<&'a ()>,
24922}
24923impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> {
24924    type Target = SwapchainImageCreateInfoANDROID;
24925    fn deref(&self) -> &Self::Target {
24926        &self.inner
24927    }
24928}
24929impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> {
24930    fn deref_mut(&mut self) -> &mut Self::Target {
24931        &mut self.inner
24932    }
24933}
24934impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
24935    pub fn usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self {
24936        self.inner.usage = usage;
24937        self
24938    }
24939    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24940    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24941    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24942    pub fn build(self) -> SwapchainImageCreateInfoANDROID {
24943        self.inner
24944    }
24945}
24946#[repr(C)]
24947#[cfg_attr(feature = "debug", derive(Debug))]
24948#[derive(Copy, Clone)]
24949#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentationPropertiesANDROID.html>"]
24950pub struct PhysicalDevicePresentationPropertiesANDROID {
24951    pub s_type: StructureType,
24952    pub p_next: *const c_void,
24953    pub shared_image: Bool32,
24954}
24955impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID {
24956    fn default() -> Self {
24957        Self {
24958            s_type: StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID,
24959            p_next: ::std::ptr::null(),
24960            shared_image: Bool32::default(),
24961        }
24962    }
24963}
24964impl PhysicalDevicePresentationPropertiesANDROID {
24965    pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24966        PhysicalDevicePresentationPropertiesANDROIDBuilder {
24967            inner: Self::default(),
24968            marker: ::std::marker::PhantomData,
24969        }
24970    }
24971}
24972#[repr(transparent)]
24973pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24974    inner: PhysicalDevicePresentationPropertiesANDROID,
24975    marker: ::std::marker::PhantomData<&'a ()>,
24976}
24977impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24978    type Target = PhysicalDevicePresentationPropertiesANDROID;
24979    fn deref(&self) -> &Self::Target {
24980        &self.inner
24981    }
24982}
24983impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24984    fn deref_mut(&mut self) -> &mut Self::Target {
24985        &mut self.inner
24986    }
24987}
24988impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
24989    pub fn shared_image(mut self, shared_image: bool) -> Self {
24990        self.inner.shared_image = shared_image.into();
24991        self
24992    }
24993    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24994    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24995    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
24996    pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID {
24997        self.inner
24998    }
24999}
25000#[repr(C)]
25001#[cfg_attr(feature = "debug", derive(Debug))]
25002#[derive(Copy, Clone, Default)]
25003#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderResourceUsageAMD.html>"]
25004pub struct ShaderResourceUsageAMD {
25005    pub num_used_vgprs: u32,
25006    pub num_used_sgprs: u32,
25007    pub lds_size_per_local_work_group: u32,
25008    pub lds_usage_size_in_bytes: usize,
25009    pub scratch_mem_usage_in_bytes: usize,
25010}
25011impl ShaderResourceUsageAMD {
25012    pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> {
25013        ShaderResourceUsageAMDBuilder {
25014            inner: Self::default(),
25015            marker: ::std::marker::PhantomData,
25016        }
25017    }
25018}
25019#[repr(transparent)]
25020pub struct ShaderResourceUsageAMDBuilder<'a> {
25021    inner: ShaderResourceUsageAMD,
25022    marker: ::std::marker::PhantomData<&'a ()>,
25023}
25024impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> {
25025    type Target = ShaderResourceUsageAMD;
25026    fn deref(&self) -> &Self::Target {
25027        &self.inner
25028    }
25029}
25030impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> {
25031    fn deref_mut(&mut self) -> &mut Self::Target {
25032        &mut self.inner
25033    }
25034}
25035impl<'a> ShaderResourceUsageAMDBuilder<'a> {
25036    pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self {
25037        self.inner.num_used_vgprs = num_used_vgprs;
25038        self
25039    }
25040    pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self {
25041        self.inner.num_used_sgprs = num_used_sgprs;
25042        self
25043    }
25044    pub fn lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self {
25045        self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group;
25046        self
25047    }
25048    pub fn lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self {
25049        self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes;
25050        self
25051    }
25052    pub fn scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self {
25053        self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes;
25054        self
25055    }
25056    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25057    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25058    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25059    pub fn build(self) -> ShaderResourceUsageAMD {
25060        self.inner
25061    }
25062}
25063#[repr(C)]
25064#[cfg_attr(feature = "debug", derive(Debug))]
25065#[derive(Copy, Clone)]
25066#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStatisticsInfoAMD.html>"]
25067pub struct ShaderStatisticsInfoAMD {
25068    pub shader_stage_mask: ShaderStageFlags,
25069    pub resource_usage: ShaderResourceUsageAMD,
25070    pub num_physical_vgprs: u32,
25071    pub num_physical_sgprs: u32,
25072    pub num_available_vgprs: u32,
25073    pub num_available_sgprs: u32,
25074    pub compute_work_group_size: [u32; 3],
25075}
25076impl ::std::default::Default for ShaderStatisticsInfoAMD {
25077    fn default() -> Self {
25078        Self {
25079            shader_stage_mask: ShaderStageFlags::default(),
25080            resource_usage: ShaderResourceUsageAMD::default(),
25081            num_physical_vgprs: u32::default(),
25082            num_physical_sgprs: u32::default(),
25083            num_available_vgprs: u32::default(),
25084            num_available_sgprs: u32::default(),
25085            compute_work_group_size: unsafe { ::std::mem::zeroed() },
25086        }
25087    }
25088}
25089impl ShaderStatisticsInfoAMD {
25090    pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> {
25091        ShaderStatisticsInfoAMDBuilder {
25092            inner: Self::default(),
25093            marker: ::std::marker::PhantomData,
25094        }
25095    }
25096}
25097#[repr(transparent)]
25098pub struct ShaderStatisticsInfoAMDBuilder<'a> {
25099    inner: ShaderStatisticsInfoAMD,
25100    marker: ::std::marker::PhantomData<&'a ()>,
25101}
25102impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> {
25103    type Target = ShaderStatisticsInfoAMD;
25104    fn deref(&self) -> &Self::Target {
25105        &self.inner
25106    }
25107}
25108impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> {
25109    fn deref_mut(&mut self) -> &mut Self::Target {
25110        &mut self.inner
25111    }
25112}
25113impl<'a> ShaderStatisticsInfoAMDBuilder<'a> {
25114    pub fn shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self {
25115        self.inner.shader_stage_mask = shader_stage_mask;
25116        self
25117    }
25118    pub fn resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self {
25119        self.inner.resource_usage = resource_usage;
25120        self
25121    }
25122    pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self {
25123        self.inner.num_physical_vgprs = num_physical_vgprs;
25124        self
25125    }
25126    pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self {
25127        self.inner.num_physical_sgprs = num_physical_sgprs;
25128        self
25129    }
25130    pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self {
25131        self.inner.num_available_vgprs = num_available_vgprs;
25132        self
25133    }
25134    pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self {
25135        self.inner.num_available_sgprs = num_available_sgprs;
25136        self
25137    }
25138    pub fn compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self {
25139        self.inner.compute_work_group_size = compute_work_group_size;
25140        self
25141    }
25142    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25143    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25144    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25145    pub fn build(self) -> ShaderStatisticsInfoAMD {
25146        self.inner
25147    }
25148}
25149#[repr(C)]
25150#[cfg_attr(feature = "debug", derive(Debug))]
25151#[derive(Copy, Clone)]
25152#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoKHR.html>"]
25153pub struct DeviceQueueGlobalPriorityCreateInfoKHR {
25154    pub s_type: StructureType,
25155    pub p_next: *const c_void,
25156    pub global_priority: QueueGlobalPriorityKHR,
25157}
25158impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR {
25159    fn default() -> Self {
25160        Self {
25161            s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR,
25162            p_next: ::std::ptr::null(),
25163            global_priority: QueueGlobalPriorityKHR::default(),
25164        }
25165    }
25166}
25167impl DeviceQueueGlobalPriorityCreateInfoKHR {
25168    pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25169        DeviceQueueGlobalPriorityCreateInfoKHRBuilder {
25170            inner: Self::default(),
25171            marker: ::std::marker::PhantomData,
25172        }
25173    }
25174}
25175#[repr(transparent)]
25176pub struct DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25177    inner: DeviceQueueGlobalPriorityCreateInfoKHR,
25178    marker: ::std::marker::PhantomData<&'a ()>,
25179}
25180unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'_> {}
25181unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR {}
25182impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25183    type Target = DeviceQueueGlobalPriorityCreateInfoKHR;
25184    fn deref(&self) -> &Self::Target {
25185        &self.inner
25186    }
25187}
25188impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25189    fn deref_mut(&mut self) -> &mut Self::Target {
25190        &mut self.inner
25191    }
25192}
25193impl<'a> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
25194    pub fn global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self {
25195        self.inner.global_priority = global_priority;
25196        self
25197    }
25198    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25199    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25200    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25201    pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR {
25202        self.inner
25203    }
25204}
25205#[repr(C)]
25206#[cfg_attr(feature = "debug", derive(Debug))]
25207#[derive(Copy, Clone)]
25208#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.html>"]
25209pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25210    pub s_type: StructureType,
25211    pub p_next: *mut c_void,
25212    pub global_priority_query: Bool32,
25213}
25214impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25215    fn default() -> Self {
25216        Self {
25217            s_type: StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR,
25218            p_next: ::std::ptr::null_mut(),
25219            global_priority_query: Bool32::default(),
25220        }
25221    }
25222}
25223impl PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25224    pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25225        PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder {
25226            inner: Self::default(),
25227            marker: ::std::marker::PhantomData,
25228        }
25229    }
25230}
25231#[repr(transparent)]
25232pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25233    inner: PhysicalDeviceGlobalPriorityQueryFeaturesKHR,
25234    marker: ::std::marker::PhantomData<&'a ()>,
25235}
25236unsafe impl ExtendsPhysicalDeviceFeatures2
25237    for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_>
25238{
25239}
25240unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
25241unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> {}
25242unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
25243impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25244    type Target = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
25245    fn deref(&self) -> &Self::Target {
25246        &self.inner
25247    }
25248}
25249impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25250    fn deref_mut(&mut self) -> &mut Self::Target {
25251        &mut self.inner
25252    }
25253}
25254impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
25255    pub fn global_priority_query(mut self, global_priority_query: bool) -> Self {
25256        self.inner.global_priority_query = global_priority_query.into();
25257        self
25258    }
25259    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25260    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25261    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25262    pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
25263        self.inner
25264    }
25265}
25266#[repr(C)]
25267#[cfg_attr(feature = "debug", derive(Debug))]
25268#[derive(Copy, Clone)]
25269#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyGlobalPriorityPropertiesKHR.html>"]
25270pub struct QueueFamilyGlobalPriorityPropertiesKHR {
25271    pub s_type: StructureType,
25272    pub p_next: *mut c_void,
25273    pub priority_count: u32,
25274    pub priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
25275}
25276impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR {
25277    fn default() -> Self {
25278        Self {
25279            s_type: StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR,
25280            p_next: ::std::ptr::null_mut(),
25281            priority_count: u32::default(),
25282            priorities: unsafe { ::std::mem::zeroed() },
25283        }
25284    }
25285}
25286impl QueueFamilyGlobalPriorityPropertiesKHR {
25287    pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25288        QueueFamilyGlobalPriorityPropertiesKHRBuilder {
25289            inner: Self::default(),
25290            marker: ::std::marker::PhantomData,
25291        }
25292    }
25293}
25294#[repr(transparent)]
25295pub struct QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25296    inner: QueueFamilyGlobalPriorityPropertiesKHR,
25297    marker: ::std::marker::PhantomData<&'a ()>,
25298}
25299unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'_> {}
25300unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR {}
25301impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25302    type Target = QueueFamilyGlobalPriorityPropertiesKHR;
25303    fn deref(&self) -> &Self::Target {
25304        &self.inner
25305    }
25306}
25307impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25308    fn deref_mut(&mut self) -> &mut Self::Target {
25309        &mut self.inner
25310    }
25311}
25312impl<'a> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
25313    pub fn priority_count(mut self, priority_count: u32) -> Self {
25314        self.inner.priority_count = priority_count;
25315        self
25316    }
25317    pub fn priorities(
25318        mut self,
25319        priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
25320    ) -> Self {
25321        self.inner.priorities = priorities;
25322        self
25323    }
25324    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25325    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25326    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25327    pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesKHR {
25328        self.inner
25329    }
25330}
25331#[repr(C)]
25332#[cfg_attr(feature = "debug", derive(Debug))]
25333#[derive(Copy, Clone)]
25334#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html>"]
25335pub struct DebugUtilsObjectNameInfoEXT {
25336    pub s_type: StructureType,
25337    pub p_next: *const c_void,
25338    pub object_type: ObjectType,
25339    pub object_handle: u64,
25340    pub p_object_name: *const c_char,
25341}
25342impl ::std::default::Default for DebugUtilsObjectNameInfoEXT {
25343    fn default() -> Self {
25344        Self {
25345            s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
25346            p_next: ::std::ptr::null(),
25347            object_type: ObjectType::default(),
25348            object_handle: u64::default(),
25349            p_object_name: ::std::ptr::null(),
25350        }
25351    }
25352}
25353impl DebugUtilsObjectNameInfoEXT {
25354    pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
25355        DebugUtilsObjectNameInfoEXTBuilder {
25356            inner: Self::default(),
25357            marker: ::std::marker::PhantomData,
25358        }
25359    }
25360}
25361#[repr(transparent)]
25362pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
25363    inner: DebugUtilsObjectNameInfoEXT,
25364    marker: ::std::marker::PhantomData<&'a ()>,
25365}
25366impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
25367    type Target = DebugUtilsObjectNameInfoEXT;
25368    fn deref(&self) -> &Self::Target {
25369        &self.inner
25370    }
25371}
25372impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> {
25373    fn deref_mut(&mut self) -> &mut Self::Target {
25374        &mut self.inner
25375    }
25376}
25377impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
25378    pub fn object_type(mut self, object_type: ObjectType) -> Self {
25379        self.inner.object_type = object_type;
25380        self
25381    }
25382    pub fn object_handle(mut self, object_handle: u64) -> Self {
25383        self.inner.object_handle = object_handle;
25384        self
25385    }
25386    pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
25387        self.inner.p_object_name = object_name.as_ptr();
25388        self
25389    }
25390    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25391    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25392    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25393    pub fn build(self) -> DebugUtilsObjectNameInfoEXT {
25394        self.inner
25395    }
25396}
25397#[repr(C)]
25398#[cfg_attr(feature = "debug", derive(Debug))]
25399#[derive(Copy, Clone)]
25400#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html>"]
25401pub struct DebugUtilsObjectTagInfoEXT {
25402    pub s_type: StructureType,
25403    pub p_next: *const c_void,
25404    pub object_type: ObjectType,
25405    pub object_handle: u64,
25406    pub tag_name: u64,
25407    pub tag_size: usize,
25408    pub p_tag: *const c_void,
25409}
25410impl ::std::default::Default for DebugUtilsObjectTagInfoEXT {
25411    fn default() -> Self {
25412        Self {
25413            s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
25414            p_next: ::std::ptr::null(),
25415            object_type: ObjectType::default(),
25416            object_handle: u64::default(),
25417            tag_name: u64::default(),
25418            tag_size: usize::default(),
25419            p_tag: ::std::ptr::null(),
25420        }
25421    }
25422}
25423impl DebugUtilsObjectTagInfoEXT {
25424    pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
25425        DebugUtilsObjectTagInfoEXTBuilder {
25426            inner: Self::default(),
25427            marker: ::std::marker::PhantomData,
25428        }
25429    }
25430}
25431#[repr(transparent)]
25432pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> {
25433    inner: DebugUtilsObjectTagInfoEXT,
25434    marker: ::std::marker::PhantomData<&'a ()>,
25435}
25436impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> {
25437    type Target = DebugUtilsObjectTagInfoEXT;
25438    fn deref(&self) -> &Self::Target {
25439        &self.inner
25440    }
25441}
25442impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> {
25443    fn deref_mut(&mut self) -> &mut Self::Target {
25444        &mut self.inner
25445    }
25446}
25447impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
25448    pub fn object_type(mut self, object_type: ObjectType) -> Self {
25449        self.inner.object_type = object_type;
25450        self
25451    }
25452    pub fn object_handle(mut self, object_handle: u64) -> Self {
25453        self.inner.object_handle = object_handle;
25454        self
25455    }
25456    pub fn tag_name(mut self, tag_name: u64) -> Self {
25457        self.inner.tag_name = tag_name;
25458        self
25459    }
25460    pub fn tag(mut self, tag: &'a [u8]) -> Self {
25461        self.inner.tag_size = tag.len();
25462        self.inner.p_tag = tag.as_ptr() as *const c_void;
25463        self
25464    }
25465    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25466    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25467    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25468    pub fn build(self) -> DebugUtilsObjectTagInfoEXT {
25469        self.inner
25470    }
25471}
25472#[repr(C)]
25473#[cfg_attr(feature = "debug", derive(Debug))]
25474#[derive(Copy, Clone)]
25475#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsLabelEXT.html>"]
25476pub struct DebugUtilsLabelEXT {
25477    pub s_type: StructureType,
25478    pub p_next: *const c_void,
25479    pub p_label_name: *const c_char,
25480    pub color: [f32; 4],
25481}
25482impl ::std::default::Default for DebugUtilsLabelEXT {
25483    fn default() -> Self {
25484        Self {
25485            s_type: StructureType::DEBUG_UTILS_LABEL_EXT,
25486            p_next: ::std::ptr::null(),
25487            p_label_name: ::std::ptr::null(),
25488            color: unsafe { ::std::mem::zeroed() },
25489        }
25490    }
25491}
25492impl DebugUtilsLabelEXT {
25493    pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> {
25494        DebugUtilsLabelEXTBuilder {
25495            inner: Self::default(),
25496            marker: ::std::marker::PhantomData,
25497        }
25498    }
25499}
25500#[repr(transparent)]
25501pub struct DebugUtilsLabelEXTBuilder<'a> {
25502    inner: DebugUtilsLabelEXT,
25503    marker: ::std::marker::PhantomData<&'a ()>,
25504}
25505impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> {
25506    type Target = DebugUtilsLabelEXT;
25507    fn deref(&self) -> &Self::Target {
25508        &self.inner
25509    }
25510}
25511impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> {
25512    fn deref_mut(&mut self) -> &mut Self::Target {
25513        &mut self.inner
25514    }
25515}
25516impl<'a> DebugUtilsLabelEXTBuilder<'a> {
25517    pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self {
25518        self.inner.p_label_name = label_name.as_ptr();
25519        self
25520    }
25521    pub fn color(mut self, color: [f32; 4]) -> Self {
25522        self.inner.color = color;
25523        self
25524    }
25525    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25526    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25527    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25528    pub fn build(self) -> DebugUtilsLabelEXT {
25529        self.inner
25530    }
25531}
25532#[repr(C)]
25533#[derive(Copy, Clone)]
25534#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>"]
25535pub struct DebugUtilsMessengerCreateInfoEXT {
25536    pub s_type: StructureType,
25537    pub p_next: *const c_void,
25538    pub flags: DebugUtilsMessengerCreateFlagsEXT,
25539    pub message_severity: DebugUtilsMessageSeverityFlagsEXT,
25540    pub message_type: DebugUtilsMessageTypeFlagsEXT,
25541    pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
25542    pub p_user_data: *mut c_void,
25543}
25544#[cfg(feature = "debug")]
25545impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
25546    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
25547        fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT")
25548            .field("s_type", &self.s_type)
25549            .field("p_next", &self.p_next)
25550            .field("flags", &self.flags)
25551            .field("message_severity", &self.message_severity)
25552            .field("message_type", &self.message_type)
25553            .field(
25554                "pfn_user_callback",
25555                &(self.pfn_user_callback.map(|x| x as *const ())),
25556            )
25557            .field("p_user_data", &self.p_user_data)
25558            .finish()
25559    }
25560}
25561impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT {
25562    fn default() -> Self {
25563        Self {
25564            s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
25565            p_next: ::std::ptr::null(),
25566            flags: DebugUtilsMessengerCreateFlagsEXT::default(),
25567            message_severity: DebugUtilsMessageSeverityFlagsEXT::default(),
25568            message_type: DebugUtilsMessageTypeFlagsEXT::default(),
25569            pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(),
25570            p_user_data: ::std::ptr::null_mut(),
25571        }
25572    }
25573}
25574impl DebugUtilsMessengerCreateInfoEXT {
25575    pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25576        DebugUtilsMessengerCreateInfoEXTBuilder {
25577            inner: Self::default(),
25578            marker: ::std::marker::PhantomData,
25579        }
25580    }
25581}
25582#[repr(transparent)]
25583pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25584    inner: DebugUtilsMessengerCreateInfoEXT,
25585    marker: ::std::marker::PhantomData<&'a ()>,
25586}
25587unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {}
25588unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {}
25589impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25590    type Target = DebugUtilsMessengerCreateInfoEXT;
25591    fn deref(&self) -> &Self::Target {
25592        &self.inner
25593    }
25594}
25595impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25596    fn deref_mut(&mut self) -> &mut Self::Target {
25597        &mut self.inner
25598    }
25599}
25600impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
25601    pub fn flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self {
25602        self.inner.flags = flags;
25603        self
25604    }
25605    pub fn message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self {
25606        self.inner.message_severity = message_severity;
25607        self
25608    }
25609    pub fn message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self {
25610        self.inner.message_type = message_type;
25611        self
25612    }
25613    pub fn pfn_user_callback(
25614        mut self,
25615        pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
25616    ) -> Self {
25617        self.inner.pfn_user_callback = pfn_user_callback;
25618        self
25619    }
25620    pub fn user_data(mut self, user_data: *mut c_void) -> Self {
25621        self.inner.p_user_data = user_data;
25622        self
25623    }
25624    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25625    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25626    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25627    pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT {
25628        self.inner
25629    }
25630}
25631#[repr(C)]
25632#[cfg_attr(feature = "debug", derive(Debug))]
25633#[derive(Copy, Clone)]
25634#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>"]
25635pub struct DebugUtilsMessengerCallbackDataEXT {
25636    pub s_type: StructureType,
25637    pub p_next: *const c_void,
25638    pub flags: DebugUtilsMessengerCallbackDataFlagsEXT,
25639    pub p_message_id_name: *const c_char,
25640    pub message_id_number: i32,
25641    pub p_message: *const c_char,
25642    pub queue_label_count: u32,
25643    pub p_queue_labels: *const DebugUtilsLabelEXT,
25644    pub cmd_buf_label_count: u32,
25645    pub p_cmd_buf_labels: *const DebugUtilsLabelEXT,
25646    pub object_count: u32,
25647    pub p_objects: *const DebugUtilsObjectNameInfoEXT,
25648}
25649impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT {
25650    fn default() -> Self {
25651        Self {
25652            s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
25653            p_next: ::std::ptr::null(),
25654            flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(),
25655            p_message_id_name: ::std::ptr::null(),
25656            message_id_number: i32::default(),
25657            p_message: ::std::ptr::null(),
25658            queue_label_count: u32::default(),
25659            p_queue_labels: ::std::ptr::null(),
25660            cmd_buf_label_count: u32::default(),
25661            p_cmd_buf_labels: ::std::ptr::null(),
25662            object_count: u32::default(),
25663            p_objects: ::std::ptr::null(),
25664        }
25665    }
25666}
25667impl DebugUtilsMessengerCallbackDataEXT {
25668    pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25669        DebugUtilsMessengerCallbackDataEXTBuilder {
25670            inner: Self::default(),
25671            marker: ::std::marker::PhantomData,
25672        }
25673    }
25674}
25675#[repr(transparent)]
25676pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25677    inner: DebugUtilsMessengerCallbackDataEXT,
25678    marker: ::std::marker::PhantomData<&'a ()>,
25679}
25680impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25681    type Target = DebugUtilsMessengerCallbackDataEXT;
25682    fn deref(&self) -> &Self::Target {
25683        &self.inner
25684    }
25685}
25686impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25687    fn deref_mut(&mut self) -> &mut Self::Target {
25688        &mut self.inner
25689    }
25690}
25691impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
25692    pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self {
25693        self.inner.flags = flags;
25694        self
25695    }
25696    pub fn message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self {
25697        self.inner.p_message_id_name = message_id_name.as_ptr();
25698        self
25699    }
25700    pub fn message_id_number(mut self, message_id_number: i32) -> Self {
25701        self.inner.message_id_number = message_id_number;
25702        self
25703    }
25704    pub fn message(mut self, message: &'a ::std::ffi::CStr) -> Self {
25705        self.inner.p_message = message.as_ptr();
25706        self
25707    }
25708    pub fn queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self {
25709        self.inner.queue_label_count = queue_labels.len() as _;
25710        self.inner.p_queue_labels = queue_labels.as_ptr();
25711        self
25712    }
25713    pub fn cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self {
25714        self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _;
25715        self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr();
25716        self
25717    }
25718    pub fn objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self {
25719        self.inner.object_count = objects.len() as _;
25720        self.inner.p_objects = objects.as_ptr();
25721        self
25722    }
25723    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25724    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25725    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25726    pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT {
25727        self.inner
25728    }
25729}
25730#[repr(C)]
25731#[cfg_attr(feature = "debug", derive(Debug))]
25732#[derive(Copy, Clone)]
25733#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html>"]
25734pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25735    pub s_type: StructureType,
25736    pub p_next: *mut c_void,
25737    pub device_memory_report: Bool32,
25738}
25739impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25740    fn default() -> Self {
25741        Self {
25742            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
25743            p_next: ::std::ptr::null_mut(),
25744            device_memory_report: Bool32::default(),
25745        }
25746    }
25747}
25748impl PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25749    pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25750        PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder {
25751            inner: Self::default(),
25752            marker: ::std::marker::PhantomData,
25753        }
25754    }
25755}
25756#[repr(transparent)]
25757pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25758    inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT,
25759    marker: ::std::marker::PhantomData<&'a ()>,
25760}
25761unsafe impl ExtendsPhysicalDeviceFeatures2
25762    for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_>
25763{
25764}
25765unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT {}
25766unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {}
25767unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {}
25768impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25769    type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
25770    fn deref(&self) -> &Self::Target {
25771        &self.inner
25772    }
25773}
25774impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25775    fn deref_mut(&mut self) -> &mut Self::Target {
25776        &mut self.inner
25777    }
25778}
25779impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
25780    pub fn device_memory_report(mut self, device_memory_report: bool) -> Self {
25781        self.inner.device_memory_report = device_memory_report.into();
25782        self
25783    }
25784    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25785    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25786    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25787    pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT {
25788        self.inner
25789    }
25790}
25791#[repr(C)]
25792#[derive(Copy, Clone)]
25793#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html>"]
25794pub struct DeviceDeviceMemoryReportCreateInfoEXT {
25795    pub s_type: StructureType,
25796    pub p_next: *const c_void,
25797    pub flags: DeviceMemoryReportFlagsEXT,
25798    pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
25799    pub p_user_data: *mut c_void,
25800}
25801#[cfg(feature = "debug")]
25802impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT {
25803    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
25804        fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT")
25805            .field("s_type", &self.s_type)
25806            .field("p_next", &self.p_next)
25807            .field("flags", &self.flags)
25808            .field(
25809                "pfn_user_callback",
25810                &(self.pfn_user_callback.map(|x| x as *const ())),
25811            )
25812            .field("p_user_data", &self.p_user_data)
25813            .finish()
25814    }
25815}
25816impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT {
25817    fn default() -> Self {
25818        Self {
25819            s_type: StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
25820            p_next: ::std::ptr::null(),
25821            flags: DeviceMemoryReportFlagsEXT::default(),
25822            pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(),
25823            p_user_data: ::std::ptr::null_mut(),
25824        }
25825    }
25826}
25827impl DeviceDeviceMemoryReportCreateInfoEXT {
25828    pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25829        DeviceDeviceMemoryReportCreateInfoEXTBuilder {
25830            inner: Self::default(),
25831            marker: ::std::marker::PhantomData,
25832        }
25833    }
25834}
25835#[repr(transparent)]
25836pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25837    inner: DeviceDeviceMemoryReportCreateInfoEXT,
25838    marker: ::std::marker::PhantomData<&'a ()>,
25839}
25840unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {}
25841unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {}
25842impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25843    type Target = DeviceDeviceMemoryReportCreateInfoEXT;
25844    fn deref(&self) -> &Self::Target {
25845        &self.inner
25846    }
25847}
25848impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25849    fn deref_mut(&mut self) -> &mut Self::Target {
25850        &mut self.inner
25851    }
25852}
25853impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
25854    pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
25855        self.inner.flags = flags;
25856        self
25857    }
25858    pub fn pfn_user_callback(
25859        mut self,
25860        pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
25861    ) -> Self {
25862        self.inner.pfn_user_callback = pfn_user_callback;
25863        self
25864    }
25865    pub fn user_data(mut self, user_data: *mut c_void) -> Self {
25866        self.inner.p_user_data = user_data;
25867        self
25868    }
25869    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25870    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25871    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25872    pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT {
25873        self.inner
25874    }
25875}
25876#[repr(C)]
25877#[cfg_attr(feature = "debug", derive(Debug))]
25878#[derive(Copy, Clone)]
25879#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportCallbackDataEXT.html>"]
25880pub struct DeviceMemoryReportCallbackDataEXT {
25881    pub s_type: StructureType,
25882    pub p_next: *mut c_void,
25883    pub flags: DeviceMemoryReportFlagsEXT,
25884    pub ty: DeviceMemoryReportEventTypeEXT,
25885    pub memory_object_id: u64,
25886    pub size: DeviceSize,
25887    pub object_type: ObjectType,
25888    pub object_handle: u64,
25889    pub heap_index: u32,
25890}
25891impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT {
25892    fn default() -> Self {
25893        Self {
25894            s_type: StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
25895            p_next: ::std::ptr::null_mut(),
25896            flags: DeviceMemoryReportFlagsEXT::default(),
25897            ty: DeviceMemoryReportEventTypeEXT::default(),
25898            memory_object_id: u64::default(),
25899            size: DeviceSize::default(),
25900            object_type: ObjectType::default(),
25901            object_handle: u64::default(),
25902            heap_index: u32::default(),
25903        }
25904    }
25905}
25906impl DeviceMemoryReportCallbackDataEXT {
25907    pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25908        DeviceMemoryReportCallbackDataEXTBuilder {
25909            inner: Self::default(),
25910            marker: ::std::marker::PhantomData,
25911        }
25912    }
25913}
25914#[repr(transparent)]
25915pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25916    inner: DeviceMemoryReportCallbackDataEXT,
25917    marker: ::std::marker::PhantomData<&'a ()>,
25918}
25919impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25920    type Target = DeviceMemoryReportCallbackDataEXT;
25921    fn deref(&self) -> &Self::Target {
25922        &self.inner
25923    }
25924}
25925impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25926    fn deref_mut(&mut self) -> &mut Self::Target {
25927        &mut self.inner
25928    }
25929}
25930impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
25931    pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
25932        self.inner.flags = flags;
25933        self
25934    }
25935    pub fn ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self {
25936        self.inner.ty = ty;
25937        self
25938    }
25939    pub fn memory_object_id(mut self, memory_object_id: u64) -> Self {
25940        self.inner.memory_object_id = memory_object_id;
25941        self
25942    }
25943    pub fn size(mut self, size: DeviceSize) -> Self {
25944        self.inner.size = size;
25945        self
25946    }
25947    pub fn object_type(mut self, object_type: ObjectType) -> Self {
25948        self.inner.object_type = object_type;
25949        self
25950    }
25951    pub fn object_handle(mut self, object_handle: u64) -> Self {
25952        self.inner.object_handle = object_handle;
25953        self
25954    }
25955    pub fn heap_index(mut self, heap_index: u32) -> Self {
25956        self.inner.heap_index = heap_index;
25957        self
25958    }
25959    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25960    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25961    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
25962    pub fn build(self) -> DeviceMemoryReportCallbackDataEXT {
25963        self.inner
25964    }
25965}
25966#[repr(C)]
25967#[cfg_attr(feature = "debug", derive(Debug))]
25968#[derive(Copy, Clone)]
25969#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html>"]
25970pub struct ImportMemoryHostPointerInfoEXT {
25971    pub s_type: StructureType,
25972    pub p_next: *const c_void,
25973    pub handle_type: ExternalMemoryHandleTypeFlags,
25974    pub p_host_pointer: *mut c_void,
25975}
25976impl ::std::default::Default for ImportMemoryHostPointerInfoEXT {
25977    fn default() -> Self {
25978        Self {
25979            s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
25980            p_next: ::std::ptr::null(),
25981            handle_type: ExternalMemoryHandleTypeFlags::default(),
25982            p_host_pointer: ::std::ptr::null_mut(),
25983        }
25984    }
25985}
25986impl ImportMemoryHostPointerInfoEXT {
25987    pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
25988        ImportMemoryHostPointerInfoEXTBuilder {
25989            inner: Self::default(),
25990            marker: ::std::marker::PhantomData,
25991        }
25992    }
25993}
25994#[repr(transparent)]
25995pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> {
25996    inner: ImportMemoryHostPointerInfoEXT,
25997    marker: ::std::marker::PhantomData<&'a ()>,
25998}
25999unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {}
26000unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {}
26001impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> {
26002    type Target = ImportMemoryHostPointerInfoEXT;
26003    fn deref(&self) -> &Self::Target {
26004        &self.inner
26005    }
26006}
26007impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> {
26008    fn deref_mut(&mut self) -> &mut Self::Target {
26009        &mut self.inner
26010    }
26011}
26012impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
26013    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
26014        self.inner.handle_type = handle_type;
26015        self
26016    }
26017    pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self {
26018        self.inner.p_host_pointer = host_pointer;
26019        self
26020    }
26021    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26022    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26023    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26024    pub fn build(self) -> ImportMemoryHostPointerInfoEXT {
26025        self.inner
26026    }
26027}
26028#[repr(C)]
26029#[cfg_attr(feature = "debug", derive(Debug))]
26030#[derive(Copy, Clone)]
26031#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html>"]
26032pub struct MemoryHostPointerPropertiesEXT {
26033    pub s_type: StructureType,
26034    pub p_next: *mut c_void,
26035    pub memory_type_bits: u32,
26036}
26037impl ::std::default::Default for MemoryHostPointerPropertiesEXT {
26038    fn default() -> Self {
26039        Self {
26040            s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT,
26041            p_next: ::std::ptr::null_mut(),
26042            memory_type_bits: u32::default(),
26043        }
26044    }
26045}
26046impl MemoryHostPointerPropertiesEXT {
26047    pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> {
26048        MemoryHostPointerPropertiesEXTBuilder {
26049            inner: Self::default(),
26050            marker: ::std::marker::PhantomData,
26051        }
26052    }
26053}
26054#[repr(transparent)]
26055pub struct MemoryHostPointerPropertiesEXTBuilder<'a> {
26056    inner: MemoryHostPointerPropertiesEXT,
26057    marker: ::std::marker::PhantomData<&'a ()>,
26058}
26059impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> {
26060    type Target = MemoryHostPointerPropertiesEXT;
26061    fn deref(&self) -> &Self::Target {
26062        &self.inner
26063    }
26064}
26065impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> {
26066    fn deref_mut(&mut self) -> &mut Self::Target {
26067        &mut self.inner
26068    }
26069}
26070impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
26071    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
26072        self.inner.memory_type_bits = memory_type_bits;
26073        self
26074    }
26075    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26076    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26077    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26078    pub fn build(self) -> MemoryHostPointerPropertiesEXT {
26079        self.inner
26080    }
26081}
26082#[repr(C)]
26083#[cfg_attr(feature = "debug", derive(Debug))]
26084#[derive(Copy, Clone)]
26085#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>"]
26086pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
26087    pub s_type: StructureType,
26088    pub p_next: *mut c_void,
26089    pub min_imported_host_pointer_alignment: DeviceSize,
26090}
26091impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT {
26092    fn default() -> Self {
26093        Self {
26094            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
26095            p_next: ::std::ptr::null_mut(),
26096            min_imported_host_pointer_alignment: DeviceSize::default(),
26097        }
26098    }
26099}
26100impl PhysicalDeviceExternalMemoryHostPropertiesEXT {
26101    pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26102        PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder {
26103            inner: Self::default(),
26104            marker: ::std::marker::PhantomData,
26105        }
26106    }
26107}
26108#[repr(transparent)]
26109pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26110    inner: PhysicalDeviceExternalMemoryHostPropertiesEXT,
26111    marker: ::std::marker::PhantomData<&'a ()>,
26112}
26113unsafe impl ExtendsPhysicalDeviceProperties2
26114    for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_>
26115{
26116}
26117unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {}
26118impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26119    type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT;
26120    fn deref(&self) -> &Self::Target {
26121        &self.inner
26122    }
26123}
26124impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26125    fn deref_mut(&mut self) -> &mut Self::Target {
26126        &mut self.inner
26127    }
26128}
26129impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
26130    pub fn min_imported_host_pointer_alignment(
26131        mut self,
26132        min_imported_host_pointer_alignment: DeviceSize,
26133    ) -> Self {
26134        self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment;
26135        self
26136    }
26137    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26138    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26139    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26140    pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
26141        self.inner
26142    }
26143}
26144#[repr(C)]
26145#[cfg_attr(feature = "debug", derive(Debug))]
26146#[derive(Copy, Clone)]
26147#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>"]
26148pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
26149    pub s_type: StructureType,
26150    pub p_next: *mut c_void,
26151    pub primitive_overestimation_size: f32,
26152    pub max_extra_primitive_overestimation_size: f32,
26153    pub extra_primitive_overestimation_size_granularity: f32,
26154    pub primitive_underestimation: Bool32,
26155    pub conservative_point_and_line_rasterization: Bool32,
26156    pub degenerate_triangles_rasterized: Bool32,
26157    pub degenerate_lines_rasterized: Bool32,
26158    pub fully_covered_fragment_shader_input_variable: Bool32,
26159    pub conservative_rasterization_post_depth_coverage: Bool32,
26160}
26161impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
26162    fn default() -> Self {
26163        Self {
26164            s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
26165            p_next: ::std::ptr::null_mut(),
26166            primitive_overestimation_size: f32::default(),
26167            max_extra_primitive_overestimation_size: f32::default(),
26168            extra_primitive_overestimation_size_granularity: f32::default(),
26169            primitive_underestimation: Bool32::default(),
26170            conservative_point_and_line_rasterization: Bool32::default(),
26171            degenerate_triangles_rasterized: Bool32::default(),
26172            degenerate_lines_rasterized: Bool32::default(),
26173            fully_covered_fragment_shader_input_variable: Bool32::default(),
26174            conservative_rasterization_post_depth_coverage: Bool32::default(),
26175        }
26176    }
26177}
26178impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
26179    pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26180        PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder {
26181            inner: Self::default(),
26182            marker: ::std::marker::PhantomData,
26183        }
26184    }
26185}
26186#[repr(transparent)]
26187pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26188    inner: PhysicalDeviceConservativeRasterizationPropertiesEXT,
26189    marker: ::std::marker::PhantomData<&'a ()>,
26190}
26191unsafe impl ExtendsPhysicalDeviceProperties2
26192    for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_>
26193{
26194}
26195unsafe impl ExtendsPhysicalDeviceProperties2
26196    for PhysicalDeviceConservativeRasterizationPropertiesEXT
26197{
26198}
26199impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26200    type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT;
26201    fn deref(&self) -> &Self::Target {
26202        &self.inner
26203    }
26204}
26205impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26206    fn deref_mut(&mut self) -> &mut Self::Target {
26207        &mut self.inner
26208    }
26209}
26210impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
26211    pub fn primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self {
26212        self.inner.primitive_overestimation_size = primitive_overestimation_size;
26213        self
26214    }
26215    pub fn max_extra_primitive_overestimation_size(
26216        mut self,
26217        max_extra_primitive_overestimation_size: f32,
26218    ) -> Self {
26219        self.inner.max_extra_primitive_overestimation_size =
26220            max_extra_primitive_overestimation_size;
26221        self
26222    }
26223    pub fn extra_primitive_overestimation_size_granularity(
26224        mut self,
26225        extra_primitive_overestimation_size_granularity: f32,
26226    ) -> Self {
26227        self.inner.extra_primitive_overestimation_size_granularity =
26228            extra_primitive_overestimation_size_granularity;
26229        self
26230    }
26231    pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self {
26232        self.inner.primitive_underestimation = primitive_underestimation.into();
26233        self
26234    }
26235    pub fn conservative_point_and_line_rasterization(
26236        mut self,
26237        conservative_point_and_line_rasterization: bool,
26238    ) -> Self {
26239        self.inner.conservative_point_and_line_rasterization =
26240            conservative_point_and_line_rasterization.into();
26241        self
26242    }
26243    pub fn degenerate_triangles_rasterized(
26244        mut self,
26245        degenerate_triangles_rasterized: bool,
26246    ) -> Self {
26247        self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into();
26248        self
26249    }
26250    pub fn degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self {
26251        self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into();
26252        self
26253    }
26254    pub fn fully_covered_fragment_shader_input_variable(
26255        mut self,
26256        fully_covered_fragment_shader_input_variable: bool,
26257    ) -> Self {
26258        self.inner.fully_covered_fragment_shader_input_variable =
26259            fully_covered_fragment_shader_input_variable.into();
26260        self
26261    }
26262    pub fn conservative_rasterization_post_depth_coverage(
26263        mut self,
26264        conservative_rasterization_post_depth_coverage: bool,
26265    ) -> Self {
26266        self.inner.conservative_rasterization_post_depth_coverage =
26267            conservative_rasterization_post_depth_coverage.into();
26268        self
26269    }
26270    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26271    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26272    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26273    pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
26274        self.inner
26275    }
26276}
26277#[repr(C)]
26278#[cfg_attr(feature = "debug", derive(Debug))]
26279#[derive(Copy, Clone)]
26280#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCalibratedTimestampInfoEXT.html>"]
26281pub struct CalibratedTimestampInfoEXT {
26282    pub s_type: StructureType,
26283    pub p_next: *const c_void,
26284    pub time_domain: TimeDomainEXT,
26285}
26286impl ::std::default::Default for CalibratedTimestampInfoEXT {
26287    fn default() -> Self {
26288        Self {
26289            s_type: StructureType::CALIBRATED_TIMESTAMP_INFO_EXT,
26290            p_next: ::std::ptr::null(),
26291            time_domain: TimeDomainEXT::default(),
26292        }
26293    }
26294}
26295impl CalibratedTimestampInfoEXT {
26296    pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> {
26297        CalibratedTimestampInfoEXTBuilder {
26298            inner: Self::default(),
26299            marker: ::std::marker::PhantomData,
26300        }
26301    }
26302}
26303#[repr(transparent)]
26304pub struct CalibratedTimestampInfoEXTBuilder<'a> {
26305    inner: CalibratedTimestampInfoEXT,
26306    marker: ::std::marker::PhantomData<&'a ()>,
26307}
26308impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> {
26309    type Target = CalibratedTimestampInfoEXT;
26310    fn deref(&self) -> &Self::Target {
26311        &self.inner
26312    }
26313}
26314impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> {
26315    fn deref_mut(&mut self) -> &mut Self::Target {
26316        &mut self.inner
26317    }
26318}
26319impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
26320    pub fn time_domain(mut self, time_domain: TimeDomainEXT) -> Self {
26321        self.inner.time_domain = time_domain;
26322        self
26323    }
26324    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26325    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26326    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26327    pub fn build(self) -> CalibratedTimestampInfoEXT {
26328        self.inner
26329    }
26330}
26331#[repr(C)]
26332#[cfg_attr(feature = "debug", derive(Debug))]
26333#[derive(Copy, Clone)]
26334#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>"]
26335pub struct PhysicalDeviceShaderCorePropertiesAMD {
26336    pub s_type: StructureType,
26337    pub p_next: *mut c_void,
26338    pub shader_engine_count: u32,
26339    pub shader_arrays_per_engine_count: u32,
26340    pub compute_units_per_shader_array: u32,
26341    pub simd_per_compute_unit: u32,
26342    pub wavefronts_per_simd: u32,
26343    pub wavefront_size: u32,
26344    pub sgprs_per_simd: u32,
26345    pub min_sgpr_allocation: u32,
26346    pub max_sgpr_allocation: u32,
26347    pub sgpr_allocation_granularity: u32,
26348    pub vgprs_per_simd: u32,
26349    pub min_vgpr_allocation: u32,
26350    pub max_vgpr_allocation: u32,
26351    pub vgpr_allocation_granularity: u32,
26352}
26353impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD {
26354    fn default() -> Self {
26355        Self {
26356            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
26357            p_next: ::std::ptr::null_mut(),
26358            shader_engine_count: u32::default(),
26359            shader_arrays_per_engine_count: u32::default(),
26360            compute_units_per_shader_array: u32::default(),
26361            simd_per_compute_unit: u32::default(),
26362            wavefronts_per_simd: u32::default(),
26363            wavefront_size: u32::default(),
26364            sgprs_per_simd: u32::default(),
26365            min_sgpr_allocation: u32::default(),
26366            max_sgpr_allocation: u32::default(),
26367            sgpr_allocation_granularity: u32::default(),
26368            vgprs_per_simd: u32::default(),
26369            min_vgpr_allocation: u32::default(),
26370            max_vgpr_allocation: u32::default(),
26371            vgpr_allocation_granularity: u32::default(),
26372        }
26373    }
26374}
26375impl PhysicalDeviceShaderCorePropertiesAMD {
26376    pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26377        PhysicalDeviceShaderCorePropertiesAMDBuilder {
26378            inner: Self::default(),
26379            marker: ::std::marker::PhantomData,
26380        }
26381    }
26382}
26383#[repr(transparent)]
26384pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26385    inner: PhysicalDeviceShaderCorePropertiesAMD,
26386    marker: ::std::marker::PhantomData<&'a ()>,
26387}
26388unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {}
26389unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {}
26390impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26391    type Target = PhysicalDeviceShaderCorePropertiesAMD;
26392    fn deref(&self) -> &Self::Target {
26393        &self.inner
26394    }
26395}
26396impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26397    fn deref_mut(&mut self) -> &mut Self::Target {
26398        &mut self.inner
26399    }
26400}
26401impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
26402    pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self {
26403        self.inner.shader_engine_count = shader_engine_count;
26404        self
26405    }
26406    pub fn shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self {
26407        self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count;
26408        self
26409    }
26410    pub fn compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self {
26411        self.inner.compute_units_per_shader_array = compute_units_per_shader_array;
26412        self
26413    }
26414    pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self {
26415        self.inner.simd_per_compute_unit = simd_per_compute_unit;
26416        self
26417    }
26418    pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self {
26419        self.inner.wavefronts_per_simd = wavefronts_per_simd;
26420        self
26421    }
26422    pub fn wavefront_size(mut self, wavefront_size: u32) -> Self {
26423        self.inner.wavefront_size = wavefront_size;
26424        self
26425    }
26426    pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self {
26427        self.inner.sgprs_per_simd = sgprs_per_simd;
26428        self
26429    }
26430    pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self {
26431        self.inner.min_sgpr_allocation = min_sgpr_allocation;
26432        self
26433    }
26434    pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self {
26435        self.inner.max_sgpr_allocation = max_sgpr_allocation;
26436        self
26437    }
26438    pub fn sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self {
26439        self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity;
26440        self
26441    }
26442    pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self {
26443        self.inner.vgprs_per_simd = vgprs_per_simd;
26444        self
26445    }
26446    pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self {
26447        self.inner.min_vgpr_allocation = min_vgpr_allocation;
26448        self
26449    }
26450    pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self {
26451        self.inner.max_vgpr_allocation = max_vgpr_allocation;
26452        self
26453    }
26454    pub fn vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self {
26455        self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity;
26456        self
26457    }
26458    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26459    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26460    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26461    pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD {
26462        self.inner
26463    }
26464}
26465#[repr(C)]
26466#[cfg_attr(feature = "debug", derive(Debug))]
26467#[derive(Copy, Clone)]
26468#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>"]
26469pub struct PhysicalDeviceShaderCoreProperties2AMD {
26470    pub s_type: StructureType,
26471    pub p_next: *mut c_void,
26472    pub shader_core_features: ShaderCorePropertiesFlagsAMD,
26473    pub active_compute_unit_count: u32,
26474}
26475impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD {
26476    fn default() -> Self {
26477        Self {
26478            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
26479            p_next: ::std::ptr::null_mut(),
26480            shader_core_features: ShaderCorePropertiesFlagsAMD::default(),
26481            active_compute_unit_count: u32::default(),
26482        }
26483    }
26484}
26485impl PhysicalDeviceShaderCoreProperties2AMD {
26486    pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26487        PhysicalDeviceShaderCoreProperties2AMDBuilder {
26488            inner: Self::default(),
26489            marker: ::std::marker::PhantomData,
26490        }
26491    }
26492}
26493#[repr(transparent)]
26494pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26495    inner: PhysicalDeviceShaderCoreProperties2AMD,
26496    marker: ::std::marker::PhantomData<&'a ()>,
26497}
26498unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {}
26499unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {}
26500impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26501    type Target = PhysicalDeviceShaderCoreProperties2AMD;
26502    fn deref(&self) -> &Self::Target {
26503        &self.inner
26504    }
26505}
26506impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26507    fn deref_mut(&mut self) -> &mut Self::Target {
26508        &mut self.inner
26509    }
26510}
26511impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
26512    pub fn shader_core_features(
26513        mut self,
26514        shader_core_features: ShaderCorePropertiesFlagsAMD,
26515    ) -> Self {
26516        self.inner.shader_core_features = shader_core_features;
26517        self
26518    }
26519    pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self {
26520        self.inner.active_compute_unit_count = active_compute_unit_count;
26521        self
26522    }
26523    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26524    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26525    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26526    pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD {
26527        self.inner
26528    }
26529}
26530#[repr(C)]
26531#[cfg_attr(feature = "debug", derive(Debug))]
26532#[derive(Copy, Clone)]
26533#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>"]
26534pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
26535    pub s_type: StructureType,
26536    pub p_next: *const c_void,
26537    pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
26538    pub conservative_rasterization_mode: ConservativeRasterizationModeEXT,
26539    pub extra_primitive_overestimation_size: f32,
26540}
26541impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT {
26542    fn default() -> Self {
26543        Self {
26544            s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
26545            p_next: ::std::ptr::null(),
26546            flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(),
26547            conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(),
26548            extra_primitive_overestimation_size: f32::default(),
26549        }
26550    }
26551}
26552impl PipelineRasterizationConservativeStateCreateInfoEXT {
26553    pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26554        PipelineRasterizationConservativeStateCreateInfoEXTBuilder {
26555            inner: Self::default(),
26556            marker: ::std::marker::PhantomData,
26557        }
26558    }
26559}
26560#[repr(transparent)]
26561pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26562    inner: PipelineRasterizationConservativeStateCreateInfoEXT,
26563    marker: ::std::marker::PhantomData<&'a ()>,
26564}
26565unsafe impl ExtendsPipelineRasterizationStateCreateInfo
26566    for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_>
26567{
26568}
26569unsafe impl ExtendsPipelineRasterizationStateCreateInfo
26570    for PipelineRasterizationConservativeStateCreateInfoEXT
26571{
26572}
26573impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26574    type Target = PipelineRasterizationConservativeStateCreateInfoEXT;
26575    fn deref(&self) -> &Self::Target {
26576        &self.inner
26577    }
26578}
26579impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26580    fn deref_mut(&mut self) -> &mut Self::Target {
26581        &mut self.inner
26582    }
26583}
26584impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
26585    pub fn flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self {
26586        self.inner.flags = flags;
26587        self
26588    }
26589    pub fn conservative_rasterization_mode(
26590        mut self,
26591        conservative_rasterization_mode: ConservativeRasterizationModeEXT,
26592    ) -> Self {
26593        self.inner.conservative_rasterization_mode = conservative_rasterization_mode;
26594        self
26595    }
26596    pub fn extra_primitive_overestimation_size(
26597        mut self,
26598        extra_primitive_overestimation_size: f32,
26599    ) -> Self {
26600        self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size;
26601        self
26602    }
26603    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26604    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26605    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26606    pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT {
26607        self.inner
26608    }
26609}
26610#[repr(C)]
26611#[cfg_attr(feature = "debug", derive(Debug))]
26612#[derive(Copy, Clone)]
26613#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>"]
26614pub struct PhysicalDeviceDescriptorIndexingFeatures {
26615    pub s_type: StructureType,
26616    pub p_next: *mut c_void,
26617    pub shader_input_attachment_array_dynamic_indexing: Bool32,
26618    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
26619    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
26620    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
26621    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
26622    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
26623    pub shader_storage_image_array_non_uniform_indexing: Bool32,
26624    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
26625    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
26626    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
26627    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
26628    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
26629    pub descriptor_binding_storage_image_update_after_bind: Bool32,
26630    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
26631    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
26632    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
26633    pub descriptor_binding_update_unused_while_pending: Bool32,
26634    pub descriptor_binding_partially_bound: Bool32,
26635    pub descriptor_binding_variable_descriptor_count: Bool32,
26636    pub runtime_descriptor_array: Bool32,
26637}
26638impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures {
26639    fn default() -> Self {
26640        Self {
26641            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
26642            p_next: ::std::ptr::null_mut(),
26643            shader_input_attachment_array_dynamic_indexing: Bool32::default(),
26644            shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
26645            shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
26646            shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
26647            shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
26648            shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
26649            shader_storage_image_array_non_uniform_indexing: Bool32::default(),
26650            shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
26651            shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
26652            shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
26653            descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
26654            descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
26655            descriptor_binding_storage_image_update_after_bind: Bool32::default(),
26656            descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
26657            descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
26658            descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
26659            descriptor_binding_update_unused_while_pending: Bool32::default(),
26660            descriptor_binding_partially_bound: Bool32::default(),
26661            descriptor_binding_variable_descriptor_count: Bool32::default(),
26662            runtime_descriptor_array: Bool32::default(),
26663        }
26664    }
26665}
26666impl PhysicalDeviceDescriptorIndexingFeatures {
26667    pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26668        PhysicalDeviceDescriptorIndexingFeaturesBuilder {
26669            inner: Self::default(),
26670            marker: ::std::marker::PhantomData,
26671        }
26672    }
26673}
26674#[repr(transparent)]
26675pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26676    inner: PhysicalDeviceDescriptorIndexingFeatures,
26677    marker: ::std::marker::PhantomData<&'a ()>,
26678}
26679unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
26680unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures {}
26681unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
26682unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {}
26683impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26684    type Target = PhysicalDeviceDescriptorIndexingFeatures;
26685    fn deref(&self) -> &Self::Target {
26686        &self.inner
26687    }
26688}
26689impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26690    fn deref_mut(&mut self) -> &mut Self::Target {
26691        &mut self.inner
26692    }
26693}
26694impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
26695    pub fn shader_input_attachment_array_dynamic_indexing(
26696        mut self,
26697        shader_input_attachment_array_dynamic_indexing: bool,
26698    ) -> Self {
26699        self.inner.shader_input_attachment_array_dynamic_indexing =
26700            shader_input_attachment_array_dynamic_indexing.into();
26701        self
26702    }
26703    pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
26704        mut self,
26705        shader_uniform_texel_buffer_array_dynamic_indexing: bool,
26706    ) -> Self {
26707        self.inner
26708            .shader_uniform_texel_buffer_array_dynamic_indexing =
26709            shader_uniform_texel_buffer_array_dynamic_indexing.into();
26710        self
26711    }
26712    pub fn shader_storage_texel_buffer_array_dynamic_indexing(
26713        mut self,
26714        shader_storage_texel_buffer_array_dynamic_indexing: bool,
26715    ) -> Self {
26716        self.inner
26717            .shader_storage_texel_buffer_array_dynamic_indexing =
26718            shader_storage_texel_buffer_array_dynamic_indexing.into();
26719        self
26720    }
26721    pub fn shader_uniform_buffer_array_non_uniform_indexing(
26722        mut self,
26723        shader_uniform_buffer_array_non_uniform_indexing: bool,
26724    ) -> Self {
26725        self.inner.shader_uniform_buffer_array_non_uniform_indexing =
26726            shader_uniform_buffer_array_non_uniform_indexing.into();
26727        self
26728    }
26729    pub fn shader_sampled_image_array_non_uniform_indexing(
26730        mut self,
26731        shader_sampled_image_array_non_uniform_indexing: bool,
26732    ) -> Self {
26733        self.inner.shader_sampled_image_array_non_uniform_indexing =
26734            shader_sampled_image_array_non_uniform_indexing.into();
26735        self
26736    }
26737    pub fn shader_storage_buffer_array_non_uniform_indexing(
26738        mut self,
26739        shader_storage_buffer_array_non_uniform_indexing: bool,
26740    ) -> Self {
26741        self.inner.shader_storage_buffer_array_non_uniform_indexing =
26742            shader_storage_buffer_array_non_uniform_indexing.into();
26743        self
26744    }
26745    pub fn shader_storage_image_array_non_uniform_indexing(
26746        mut self,
26747        shader_storage_image_array_non_uniform_indexing: bool,
26748    ) -> Self {
26749        self.inner.shader_storage_image_array_non_uniform_indexing =
26750            shader_storage_image_array_non_uniform_indexing.into();
26751        self
26752    }
26753    pub fn shader_input_attachment_array_non_uniform_indexing(
26754        mut self,
26755        shader_input_attachment_array_non_uniform_indexing: bool,
26756    ) -> Self {
26757        self.inner
26758            .shader_input_attachment_array_non_uniform_indexing =
26759            shader_input_attachment_array_non_uniform_indexing.into();
26760        self
26761    }
26762    pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
26763        mut self,
26764        shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
26765    ) -> Self {
26766        self.inner
26767            .shader_uniform_texel_buffer_array_non_uniform_indexing =
26768            shader_uniform_texel_buffer_array_non_uniform_indexing.into();
26769        self
26770    }
26771    pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
26772        mut self,
26773        shader_storage_texel_buffer_array_non_uniform_indexing: bool,
26774    ) -> Self {
26775        self.inner
26776            .shader_storage_texel_buffer_array_non_uniform_indexing =
26777            shader_storage_texel_buffer_array_non_uniform_indexing.into();
26778        self
26779    }
26780    pub fn descriptor_binding_uniform_buffer_update_after_bind(
26781        mut self,
26782        descriptor_binding_uniform_buffer_update_after_bind: bool,
26783    ) -> Self {
26784        self.inner
26785            .descriptor_binding_uniform_buffer_update_after_bind =
26786            descriptor_binding_uniform_buffer_update_after_bind.into();
26787        self
26788    }
26789    pub fn descriptor_binding_sampled_image_update_after_bind(
26790        mut self,
26791        descriptor_binding_sampled_image_update_after_bind: bool,
26792    ) -> Self {
26793        self.inner
26794            .descriptor_binding_sampled_image_update_after_bind =
26795            descriptor_binding_sampled_image_update_after_bind.into();
26796        self
26797    }
26798    pub fn descriptor_binding_storage_image_update_after_bind(
26799        mut self,
26800        descriptor_binding_storage_image_update_after_bind: bool,
26801    ) -> Self {
26802        self.inner
26803            .descriptor_binding_storage_image_update_after_bind =
26804            descriptor_binding_storage_image_update_after_bind.into();
26805        self
26806    }
26807    pub fn descriptor_binding_storage_buffer_update_after_bind(
26808        mut self,
26809        descriptor_binding_storage_buffer_update_after_bind: bool,
26810    ) -> Self {
26811        self.inner
26812            .descriptor_binding_storage_buffer_update_after_bind =
26813            descriptor_binding_storage_buffer_update_after_bind.into();
26814        self
26815    }
26816    pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
26817        mut self,
26818        descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
26819    ) -> Self {
26820        self.inner
26821            .descriptor_binding_uniform_texel_buffer_update_after_bind =
26822            descriptor_binding_uniform_texel_buffer_update_after_bind.into();
26823        self
26824    }
26825    pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
26826        mut self,
26827        descriptor_binding_storage_texel_buffer_update_after_bind: bool,
26828    ) -> Self {
26829        self.inner
26830            .descriptor_binding_storage_texel_buffer_update_after_bind =
26831            descriptor_binding_storage_texel_buffer_update_after_bind.into();
26832        self
26833    }
26834    pub fn descriptor_binding_update_unused_while_pending(
26835        mut self,
26836        descriptor_binding_update_unused_while_pending: bool,
26837    ) -> Self {
26838        self.inner.descriptor_binding_update_unused_while_pending =
26839            descriptor_binding_update_unused_while_pending.into();
26840        self
26841    }
26842    pub fn descriptor_binding_partially_bound(
26843        mut self,
26844        descriptor_binding_partially_bound: bool,
26845    ) -> Self {
26846        self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
26847        self
26848    }
26849    pub fn descriptor_binding_variable_descriptor_count(
26850        mut self,
26851        descriptor_binding_variable_descriptor_count: bool,
26852    ) -> Self {
26853        self.inner.descriptor_binding_variable_descriptor_count =
26854            descriptor_binding_variable_descriptor_count.into();
26855        self
26856    }
26857    pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
26858        self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
26859        self
26860    }
26861    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26862    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26863    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
26864    pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures {
26865        self.inner
26866    }
26867}
26868#[repr(C)]
26869#[cfg_attr(feature = "debug", derive(Debug))]
26870#[derive(Copy, Clone)]
26871#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>"]
26872pub struct PhysicalDeviceDescriptorIndexingProperties {
26873    pub s_type: StructureType,
26874    pub p_next: *mut c_void,
26875    pub max_update_after_bind_descriptors_in_all_pools: u32,
26876    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
26877    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
26878    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
26879    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
26880    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
26881    pub robust_buffer_access_update_after_bind: Bool32,
26882    pub quad_divergent_implicit_lod: Bool32,
26883    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
26884    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
26885    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
26886    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
26887    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
26888    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
26889    pub max_per_stage_update_after_bind_resources: u32,
26890    pub max_descriptor_set_update_after_bind_samplers: u32,
26891    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
26892    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
26893    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
26894    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
26895    pub max_descriptor_set_update_after_bind_sampled_images: u32,
26896    pub max_descriptor_set_update_after_bind_storage_images: u32,
26897    pub max_descriptor_set_update_after_bind_input_attachments: u32,
26898}
26899impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties {
26900    fn default() -> Self {
26901        Self {
26902            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
26903            p_next: ::std::ptr::null_mut(),
26904            max_update_after_bind_descriptors_in_all_pools: u32::default(),
26905            shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
26906            shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
26907            shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
26908            shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
26909            shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
26910            robust_buffer_access_update_after_bind: Bool32::default(),
26911            quad_divergent_implicit_lod: Bool32::default(),
26912            max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
26913            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
26914            max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
26915            max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
26916            max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
26917            max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
26918            max_per_stage_update_after_bind_resources: u32::default(),
26919            max_descriptor_set_update_after_bind_samplers: u32::default(),
26920            max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
26921            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
26922            max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
26923            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
26924            max_descriptor_set_update_after_bind_sampled_images: u32::default(),
26925            max_descriptor_set_update_after_bind_storage_images: u32::default(),
26926            max_descriptor_set_update_after_bind_input_attachments: u32::default(),
26927        }
26928    }
26929}
26930impl PhysicalDeviceDescriptorIndexingProperties {
26931    pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26932        PhysicalDeviceDescriptorIndexingPropertiesBuilder {
26933            inner: Self::default(),
26934            marker: ::std::marker::PhantomData,
26935        }
26936    }
26937}
26938#[repr(transparent)]
26939pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26940    inner: PhysicalDeviceDescriptorIndexingProperties,
26941    marker: ::std::marker::PhantomData<&'a ()>,
26942}
26943unsafe impl ExtendsPhysicalDeviceProperties2
26944    for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_>
26945{
26946}
26947unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {}
26948impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26949    type Target = PhysicalDeviceDescriptorIndexingProperties;
26950    fn deref(&self) -> &Self::Target {
26951        &self.inner
26952    }
26953}
26954impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26955    fn deref_mut(&mut self) -> &mut Self::Target {
26956        &mut self.inner
26957    }
26958}
26959impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
26960    pub fn max_update_after_bind_descriptors_in_all_pools(
26961        mut self,
26962        max_update_after_bind_descriptors_in_all_pools: u32,
26963    ) -> Self {
26964        self.inner.max_update_after_bind_descriptors_in_all_pools =
26965            max_update_after_bind_descriptors_in_all_pools;
26966        self
26967    }
26968    pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
26969        mut self,
26970        shader_uniform_buffer_array_non_uniform_indexing_native: bool,
26971    ) -> Self {
26972        self.inner
26973            .shader_uniform_buffer_array_non_uniform_indexing_native =
26974            shader_uniform_buffer_array_non_uniform_indexing_native.into();
26975        self
26976    }
26977    pub fn shader_sampled_image_array_non_uniform_indexing_native(
26978        mut self,
26979        shader_sampled_image_array_non_uniform_indexing_native: bool,
26980    ) -> Self {
26981        self.inner
26982            .shader_sampled_image_array_non_uniform_indexing_native =
26983            shader_sampled_image_array_non_uniform_indexing_native.into();
26984        self
26985    }
26986    pub fn shader_storage_buffer_array_non_uniform_indexing_native(
26987        mut self,
26988        shader_storage_buffer_array_non_uniform_indexing_native: bool,
26989    ) -> Self {
26990        self.inner
26991            .shader_storage_buffer_array_non_uniform_indexing_native =
26992            shader_storage_buffer_array_non_uniform_indexing_native.into();
26993        self
26994    }
26995    pub fn shader_storage_image_array_non_uniform_indexing_native(
26996        mut self,
26997        shader_storage_image_array_non_uniform_indexing_native: bool,
26998    ) -> Self {
26999        self.inner
27000            .shader_storage_image_array_non_uniform_indexing_native =
27001            shader_storage_image_array_non_uniform_indexing_native.into();
27002        self
27003    }
27004    pub fn shader_input_attachment_array_non_uniform_indexing_native(
27005        mut self,
27006        shader_input_attachment_array_non_uniform_indexing_native: bool,
27007    ) -> Self {
27008        self.inner
27009            .shader_input_attachment_array_non_uniform_indexing_native =
27010            shader_input_attachment_array_non_uniform_indexing_native.into();
27011        self
27012    }
27013    pub fn robust_buffer_access_update_after_bind(
27014        mut self,
27015        robust_buffer_access_update_after_bind: bool,
27016    ) -> Self {
27017        self.inner.robust_buffer_access_update_after_bind =
27018            robust_buffer_access_update_after_bind.into();
27019        self
27020    }
27021    pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
27022        self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
27023        self
27024    }
27025    pub fn max_per_stage_descriptor_update_after_bind_samplers(
27026        mut self,
27027        max_per_stage_descriptor_update_after_bind_samplers: u32,
27028    ) -> Self {
27029        self.inner
27030            .max_per_stage_descriptor_update_after_bind_samplers =
27031            max_per_stage_descriptor_update_after_bind_samplers;
27032        self
27033    }
27034    pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
27035        mut self,
27036        max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
27037    ) -> Self {
27038        self.inner
27039            .max_per_stage_descriptor_update_after_bind_uniform_buffers =
27040            max_per_stage_descriptor_update_after_bind_uniform_buffers;
27041        self
27042    }
27043    pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
27044        mut self,
27045        max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
27046    ) -> Self {
27047        self.inner
27048            .max_per_stage_descriptor_update_after_bind_storage_buffers =
27049            max_per_stage_descriptor_update_after_bind_storage_buffers;
27050        self
27051    }
27052    pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
27053        mut self,
27054        max_per_stage_descriptor_update_after_bind_sampled_images: u32,
27055    ) -> Self {
27056        self.inner
27057            .max_per_stage_descriptor_update_after_bind_sampled_images =
27058            max_per_stage_descriptor_update_after_bind_sampled_images;
27059        self
27060    }
27061    pub fn max_per_stage_descriptor_update_after_bind_storage_images(
27062        mut self,
27063        max_per_stage_descriptor_update_after_bind_storage_images: u32,
27064    ) -> Self {
27065        self.inner
27066            .max_per_stage_descriptor_update_after_bind_storage_images =
27067            max_per_stage_descriptor_update_after_bind_storage_images;
27068        self
27069    }
27070    pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
27071        mut self,
27072        max_per_stage_descriptor_update_after_bind_input_attachments: u32,
27073    ) -> Self {
27074        self.inner
27075            .max_per_stage_descriptor_update_after_bind_input_attachments =
27076            max_per_stage_descriptor_update_after_bind_input_attachments;
27077        self
27078    }
27079    pub fn max_per_stage_update_after_bind_resources(
27080        mut self,
27081        max_per_stage_update_after_bind_resources: u32,
27082    ) -> Self {
27083        self.inner.max_per_stage_update_after_bind_resources =
27084            max_per_stage_update_after_bind_resources;
27085        self
27086    }
27087    pub fn max_descriptor_set_update_after_bind_samplers(
27088        mut self,
27089        max_descriptor_set_update_after_bind_samplers: u32,
27090    ) -> Self {
27091        self.inner.max_descriptor_set_update_after_bind_samplers =
27092            max_descriptor_set_update_after_bind_samplers;
27093        self
27094    }
27095    pub fn max_descriptor_set_update_after_bind_uniform_buffers(
27096        mut self,
27097        max_descriptor_set_update_after_bind_uniform_buffers: u32,
27098    ) -> Self {
27099        self.inner
27100            .max_descriptor_set_update_after_bind_uniform_buffers =
27101            max_descriptor_set_update_after_bind_uniform_buffers;
27102        self
27103    }
27104    pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
27105        mut self,
27106        max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
27107    ) -> Self {
27108        self.inner
27109            .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
27110            max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
27111        self
27112    }
27113    pub fn max_descriptor_set_update_after_bind_storage_buffers(
27114        mut self,
27115        max_descriptor_set_update_after_bind_storage_buffers: u32,
27116    ) -> Self {
27117        self.inner
27118            .max_descriptor_set_update_after_bind_storage_buffers =
27119            max_descriptor_set_update_after_bind_storage_buffers;
27120        self
27121    }
27122    pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
27123        mut self,
27124        max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
27125    ) -> Self {
27126        self.inner
27127            .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
27128            max_descriptor_set_update_after_bind_storage_buffers_dynamic;
27129        self
27130    }
27131    pub fn max_descriptor_set_update_after_bind_sampled_images(
27132        mut self,
27133        max_descriptor_set_update_after_bind_sampled_images: u32,
27134    ) -> Self {
27135        self.inner
27136            .max_descriptor_set_update_after_bind_sampled_images =
27137            max_descriptor_set_update_after_bind_sampled_images;
27138        self
27139    }
27140    pub fn max_descriptor_set_update_after_bind_storage_images(
27141        mut self,
27142        max_descriptor_set_update_after_bind_storage_images: u32,
27143    ) -> Self {
27144        self.inner
27145            .max_descriptor_set_update_after_bind_storage_images =
27146            max_descriptor_set_update_after_bind_storage_images;
27147        self
27148    }
27149    pub fn max_descriptor_set_update_after_bind_input_attachments(
27150        mut self,
27151        max_descriptor_set_update_after_bind_input_attachments: u32,
27152    ) -> Self {
27153        self.inner
27154            .max_descriptor_set_update_after_bind_input_attachments =
27155            max_descriptor_set_update_after_bind_input_attachments;
27156        self
27157    }
27158    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27159    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27160    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27161    pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties {
27162        self.inner
27163    }
27164}
27165#[repr(C)]
27166#[cfg_attr(feature = "debug", derive(Debug))]
27167#[derive(Copy, Clone)]
27168#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>"]
27169pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
27170    pub s_type: StructureType,
27171    pub p_next: *const c_void,
27172    pub binding_count: u32,
27173    pub p_binding_flags: *const DescriptorBindingFlags,
27174}
27175impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo {
27176    fn default() -> Self {
27177        Self {
27178            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
27179            p_next: ::std::ptr::null(),
27180            binding_count: u32::default(),
27181            p_binding_flags: ::std::ptr::null(),
27182        }
27183    }
27184}
27185impl DescriptorSetLayoutBindingFlagsCreateInfo {
27186    pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27187        DescriptorSetLayoutBindingFlagsCreateInfoBuilder {
27188            inner: Self::default(),
27189            marker: ::std::marker::PhantomData,
27190        }
27191    }
27192}
27193#[repr(transparent)]
27194pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27195    inner: DescriptorSetLayoutBindingFlagsCreateInfo,
27196    marker: ::std::marker::PhantomData<&'a ()>,
27197}
27198unsafe impl ExtendsDescriptorSetLayoutCreateInfo
27199    for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_>
27200{
27201}
27202unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {}
27203impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27204    type Target = DescriptorSetLayoutBindingFlagsCreateInfo;
27205    fn deref(&self) -> &Self::Target {
27206        &self.inner
27207    }
27208}
27209impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27210    fn deref_mut(&mut self) -> &mut Self::Target {
27211        &mut self.inner
27212    }
27213}
27214impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
27215    pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self {
27216        self.inner.binding_count = binding_flags.len() as _;
27217        self.inner.p_binding_flags = binding_flags.as_ptr();
27218        self
27219    }
27220    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27221    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27222    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27223    pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo {
27224        self.inner
27225    }
27226}
27227#[repr(C)]
27228#[cfg_attr(feature = "debug", derive(Debug))]
27229#[derive(Copy, Clone)]
27230#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>"]
27231pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
27232    pub s_type: StructureType,
27233    pub p_next: *const c_void,
27234    pub descriptor_set_count: u32,
27235    pub p_descriptor_counts: *const u32,
27236}
27237impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo {
27238    fn default() -> Self {
27239        Self {
27240            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
27241            p_next: ::std::ptr::null(),
27242            descriptor_set_count: u32::default(),
27243            p_descriptor_counts: ::std::ptr::null(),
27244        }
27245    }
27246}
27247impl DescriptorSetVariableDescriptorCountAllocateInfo {
27248    pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27249        DescriptorSetVariableDescriptorCountAllocateInfoBuilder {
27250            inner: Self::default(),
27251            marker: ::std::marker::PhantomData,
27252        }
27253    }
27254}
27255#[repr(transparent)]
27256pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27257    inner: DescriptorSetVariableDescriptorCountAllocateInfo,
27258    marker: ::std::marker::PhantomData<&'a ()>,
27259}
27260unsafe impl ExtendsDescriptorSetAllocateInfo
27261    for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_>
27262{
27263}
27264unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {}
27265impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27266    type Target = DescriptorSetVariableDescriptorCountAllocateInfo;
27267    fn deref(&self) -> &Self::Target {
27268        &self.inner
27269    }
27270}
27271impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27272    fn deref_mut(&mut self) -> &mut Self::Target {
27273        &mut self.inner
27274    }
27275}
27276impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
27277    pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self {
27278        self.inner.descriptor_set_count = descriptor_counts.len() as _;
27279        self.inner.p_descriptor_counts = descriptor_counts.as_ptr();
27280        self
27281    }
27282    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27283    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27284    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27285    pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo {
27286        self.inner
27287    }
27288}
27289#[repr(C)]
27290#[cfg_attr(feature = "debug", derive(Debug))]
27291#[derive(Copy, Clone)]
27292#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>"]
27293pub struct DescriptorSetVariableDescriptorCountLayoutSupport {
27294    pub s_type: StructureType,
27295    pub p_next: *mut c_void,
27296    pub max_variable_descriptor_count: u32,
27297}
27298impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport {
27299    fn default() -> Self {
27300        Self {
27301            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
27302            p_next: ::std::ptr::null_mut(),
27303            max_variable_descriptor_count: u32::default(),
27304        }
27305    }
27306}
27307impl DescriptorSetVariableDescriptorCountLayoutSupport {
27308    pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27309        DescriptorSetVariableDescriptorCountLayoutSupportBuilder {
27310            inner: Self::default(),
27311            marker: ::std::marker::PhantomData,
27312        }
27313    }
27314}
27315#[repr(transparent)]
27316pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27317    inner: DescriptorSetVariableDescriptorCountLayoutSupport,
27318    marker: ::std::marker::PhantomData<&'a ()>,
27319}
27320unsafe impl ExtendsDescriptorSetLayoutSupport
27321    for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_>
27322{
27323}
27324unsafe impl ExtendsDescriptorSetLayoutSupport
27325    for DescriptorSetVariableDescriptorCountLayoutSupport
27326{
27327}
27328impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27329    type Target = DescriptorSetVariableDescriptorCountLayoutSupport;
27330    fn deref(&self) -> &Self::Target {
27331        &self.inner
27332    }
27333}
27334impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27335    fn deref_mut(&mut self) -> &mut Self::Target {
27336        &mut self.inner
27337    }
27338}
27339impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
27340    pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self {
27341        self.inner.max_variable_descriptor_count = max_variable_descriptor_count;
27342        self
27343    }
27344    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27345    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27346    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27347    pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport {
27348        self.inner
27349    }
27350}
27351#[repr(C)]
27352#[cfg_attr(feature = "debug", derive(Debug))]
27353#[derive(Copy, Clone)]
27354#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription2.html>"]
27355pub struct AttachmentDescription2 {
27356    pub s_type: StructureType,
27357    pub p_next: *const c_void,
27358    pub flags: AttachmentDescriptionFlags,
27359    pub format: Format,
27360    pub samples: SampleCountFlags,
27361    pub load_op: AttachmentLoadOp,
27362    pub store_op: AttachmentStoreOp,
27363    pub stencil_load_op: AttachmentLoadOp,
27364    pub stencil_store_op: AttachmentStoreOp,
27365    pub initial_layout: ImageLayout,
27366    pub final_layout: ImageLayout,
27367}
27368impl ::std::default::Default for AttachmentDescription2 {
27369    fn default() -> Self {
27370        Self {
27371            s_type: StructureType::ATTACHMENT_DESCRIPTION_2,
27372            p_next: ::std::ptr::null(),
27373            flags: AttachmentDescriptionFlags::default(),
27374            format: Format::default(),
27375            samples: SampleCountFlags::default(),
27376            load_op: AttachmentLoadOp::default(),
27377            store_op: AttachmentStoreOp::default(),
27378            stencil_load_op: AttachmentLoadOp::default(),
27379            stencil_store_op: AttachmentStoreOp::default(),
27380            initial_layout: ImageLayout::default(),
27381            final_layout: ImageLayout::default(),
27382        }
27383    }
27384}
27385impl AttachmentDescription2 {
27386    pub fn builder<'a>() -> AttachmentDescription2Builder<'a> {
27387        AttachmentDescription2Builder {
27388            inner: Self::default(),
27389            marker: ::std::marker::PhantomData,
27390        }
27391    }
27392}
27393#[repr(transparent)]
27394pub struct AttachmentDescription2Builder<'a> {
27395    inner: AttachmentDescription2,
27396    marker: ::std::marker::PhantomData<&'a ()>,
27397}
27398pub unsafe trait ExtendsAttachmentDescription2 {}
27399impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> {
27400    type Target = AttachmentDescription2;
27401    fn deref(&self) -> &Self::Target {
27402        &self.inner
27403    }
27404}
27405impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> {
27406    fn deref_mut(&mut self) -> &mut Self::Target {
27407        &mut self.inner
27408    }
27409}
27410impl<'a> AttachmentDescription2Builder<'a> {
27411    pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
27412        self.inner.flags = flags;
27413        self
27414    }
27415    pub fn format(mut self, format: Format) -> Self {
27416        self.inner.format = format;
27417        self
27418    }
27419    pub fn samples(mut self, samples: SampleCountFlags) -> Self {
27420        self.inner.samples = samples;
27421        self
27422    }
27423    pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
27424        self.inner.load_op = load_op;
27425        self
27426    }
27427    pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
27428        self.inner.store_op = store_op;
27429        self
27430    }
27431    pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
27432        self.inner.stencil_load_op = stencil_load_op;
27433        self
27434    }
27435    pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
27436        self.inner.stencil_store_op = stencil_store_op;
27437        self
27438    }
27439    pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
27440        self.inner.initial_layout = initial_layout;
27441        self
27442    }
27443    pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
27444        self.inner.final_layout = final_layout;
27445        self
27446    }
27447    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27448    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27449    #[doc = r" valid extension structs can be pushed into the chain."]
27450    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27451    #[doc = r" chain will look like `A -> D -> B -> C`."]
27452    pub fn push_next<T: ExtendsAttachmentDescription2>(mut self, next: &'a mut T) -> Self {
27453        unsafe {
27454            let next_ptr = <*const T>::cast(next);
27455            let last_next = ptr_chain_iter(next).last().unwrap();
27456            (*last_next).p_next = self.inner.p_next as _;
27457            self.inner.p_next = next_ptr;
27458        }
27459        self
27460    }
27461    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27462    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27463    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27464    pub fn build(self) -> AttachmentDescription2 {
27465        self.inner
27466    }
27467}
27468#[repr(C)]
27469#[cfg_attr(feature = "debug", derive(Debug))]
27470#[derive(Copy, Clone)]
27471#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference2.html>"]
27472pub struct AttachmentReference2 {
27473    pub s_type: StructureType,
27474    pub p_next: *const c_void,
27475    pub attachment: u32,
27476    pub layout: ImageLayout,
27477    pub aspect_mask: ImageAspectFlags,
27478}
27479impl ::std::default::Default for AttachmentReference2 {
27480    fn default() -> Self {
27481        Self {
27482            s_type: StructureType::ATTACHMENT_REFERENCE_2,
27483            p_next: ::std::ptr::null(),
27484            attachment: u32::default(),
27485            layout: ImageLayout::default(),
27486            aspect_mask: ImageAspectFlags::default(),
27487        }
27488    }
27489}
27490impl AttachmentReference2 {
27491    pub fn builder<'a>() -> AttachmentReference2Builder<'a> {
27492        AttachmentReference2Builder {
27493            inner: Self::default(),
27494            marker: ::std::marker::PhantomData,
27495        }
27496    }
27497}
27498#[repr(transparent)]
27499pub struct AttachmentReference2Builder<'a> {
27500    inner: AttachmentReference2,
27501    marker: ::std::marker::PhantomData<&'a ()>,
27502}
27503pub unsafe trait ExtendsAttachmentReference2 {}
27504impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> {
27505    type Target = AttachmentReference2;
27506    fn deref(&self) -> &Self::Target {
27507        &self.inner
27508    }
27509}
27510impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> {
27511    fn deref_mut(&mut self) -> &mut Self::Target {
27512        &mut self.inner
27513    }
27514}
27515impl<'a> AttachmentReference2Builder<'a> {
27516    pub fn attachment(mut self, attachment: u32) -> Self {
27517        self.inner.attachment = attachment;
27518        self
27519    }
27520    pub fn layout(mut self, layout: ImageLayout) -> Self {
27521        self.inner.layout = layout;
27522        self
27523    }
27524    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
27525        self.inner.aspect_mask = aspect_mask;
27526        self
27527    }
27528    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27529    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27530    #[doc = r" valid extension structs can be pushed into the chain."]
27531    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27532    #[doc = r" chain will look like `A -> D -> B -> C`."]
27533    pub fn push_next<T: ExtendsAttachmentReference2>(mut self, next: &'a mut T) -> Self {
27534        unsafe {
27535            let next_ptr = <*const T>::cast(next);
27536            let last_next = ptr_chain_iter(next).last().unwrap();
27537            (*last_next).p_next = self.inner.p_next as _;
27538            self.inner.p_next = next_ptr;
27539        }
27540        self
27541    }
27542    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27543    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27544    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27545    pub fn build(self) -> AttachmentReference2 {
27546        self.inner
27547    }
27548}
27549#[repr(C)]
27550#[cfg_attr(feature = "debug", derive(Debug))]
27551#[derive(Copy, Clone)]
27552#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription2.html>"]
27553pub struct SubpassDescription2 {
27554    pub s_type: StructureType,
27555    pub p_next: *const c_void,
27556    pub flags: SubpassDescriptionFlags,
27557    pub pipeline_bind_point: PipelineBindPoint,
27558    pub view_mask: u32,
27559    pub input_attachment_count: u32,
27560    pub p_input_attachments: *const AttachmentReference2,
27561    pub color_attachment_count: u32,
27562    pub p_color_attachments: *const AttachmentReference2,
27563    pub p_resolve_attachments: *const AttachmentReference2,
27564    pub p_depth_stencil_attachment: *const AttachmentReference2,
27565    pub preserve_attachment_count: u32,
27566    pub p_preserve_attachments: *const u32,
27567}
27568impl ::std::default::Default for SubpassDescription2 {
27569    fn default() -> Self {
27570        Self {
27571            s_type: StructureType::SUBPASS_DESCRIPTION_2,
27572            p_next: ::std::ptr::null(),
27573            flags: SubpassDescriptionFlags::default(),
27574            pipeline_bind_point: PipelineBindPoint::default(),
27575            view_mask: u32::default(),
27576            input_attachment_count: u32::default(),
27577            p_input_attachments: ::std::ptr::null(),
27578            color_attachment_count: u32::default(),
27579            p_color_attachments: ::std::ptr::null(),
27580            p_resolve_attachments: ::std::ptr::null(),
27581            p_depth_stencil_attachment: ::std::ptr::null(),
27582            preserve_attachment_count: u32::default(),
27583            p_preserve_attachments: ::std::ptr::null(),
27584        }
27585    }
27586}
27587impl SubpassDescription2 {
27588    pub fn builder<'a>() -> SubpassDescription2Builder<'a> {
27589        SubpassDescription2Builder {
27590            inner: Self::default(),
27591            marker: ::std::marker::PhantomData,
27592        }
27593    }
27594}
27595#[repr(transparent)]
27596pub struct SubpassDescription2Builder<'a> {
27597    inner: SubpassDescription2,
27598    marker: ::std::marker::PhantomData<&'a ()>,
27599}
27600pub unsafe trait ExtendsSubpassDescription2 {}
27601impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> {
27602    type Target = SubpassDescription2;
27603    fn deref(&self) -> &Self::Target {
27604        &self.inner
27605    }
27606}
27607impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> {
27608    fn deref_mut(&mut self) -> &mut Self::Target {
27609        &mut self.inner
27610    }
27611}
27612impl<'a> SubpassDescription2Builder<'a> {
27613    pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
27614        self.inner.flags = flags;
27615        self
27616    }
27617    pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
27618        self.inner.pipeline_bind_point = pipeline_bind_point;
27619        self
27620    }
27621    pub fn view_mask(mut self, view_mask: u32) -> Self {
27622        self.inner.view_mask = view_mask;
27623        self
27624    }
27625    pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self {
27626        self.inner.input_attachment_count = input_attachments.len() as _;
27627        self.inner.p_input_attachments = input_attachments.as_ptr();
27628        self
27629    }
27630    pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self {
27631        self.inner.color_attachment_count = color_attachments.len() as _;
27632        self.inner.p_color_attachments = color_attachments.as_ptr();
27633        self
27634    }
27635    pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self {
27636        self.inner.color_attachment_count = resolve_attachments.len() as _;
27637        self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
27638        self
27639    }
27640    pub fn depth_stencil_attachment(
27641        mut self,
27642        depth_stencil_attachment: &'a AttachmentReference2,
27643    ) -> Self {
27644        self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
27645        self
27646    }
27647    pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
27648        self.inner.preserve_attachment_count = preserve_attachments.len() as _;
27649        self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
27650        self
27651    }
27652    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27653    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27654    #[doc = r" valid extension structs can be pushed into the chain."]
27655    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27656    #[doc = r" chain will look like `A -> D -> B -> C`."]
27657    pub fn push_next<T: ExtendsSubpassDescription2>(mut self, next: &'a mut T) -> Self {
27658        unsafe {
27659            let next_ptr = <*const T>::cast(next);
27660            let last_next = ptr_chain_iter(next).last().unwrap();
27661            (*last_next).p_next = self.inner.p_next as _;
27662            self.inner.p_next = next_ptr;
27663        }
27664        self
27665    }
27666    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27667    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27668    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27669    pub fn build(self) -> SubpassDescription2 {
27670        self.inner
27671    }
27672}
27673#[repr(C)]
27674#[cfg_attr(feature = "debug", derive(Debug))]
27675#[derive(Copy, Clone)]
27676#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency2.html>"]
27677pub struct SubpassDependency2 {
27678    pub s_type: StructureType,
27679    pub p_next: *const c_void,
27680    pub src_subpass: u32,
27681    pub dst_subpass: u32,
27682    pub src_stage_mask: PipelineStageFlags,
27683    pub dst_stage_mask: PipelineStageFlags,
27684    pub src_access_mask: AccessFlags,
27685    pub dst_access_mask: AccessFlags,
27686    pub dependency_flags: DependencyFlags,
27687    pub view_offset: i32,
27688}
27689impl ::std::default::Default for SubpassDependency2 {
27690    fn default() -> Self {
27691        Self {
27692            s_type: StructureType::SUBPASS_DEPENDENCY_2,
27693            p_next: ::std::ptr::null(),
27694            src_subpass: u32::default(),
27695            dst_subpass: u32::default(),
27696            src_stage_mask: PipelineStageFlags::default(),
27697            dst_stage_mask: PipelineStageFlags::default(),
27698            src_access_mask: AccessFlags::default(),
27699            dst_access_mask: AccessFlags::default(),
27700            dependency_flags: DependencyFlags::default(),
27701            view_offset: i32::default(),
27702        }
27703    }
27704}
27705impl SubpassDependency2 {
27706    pub fn builder<'a>() -> SubpassDependency2Builder<'a> {
27707        SubpassDependency2Builder {
27708            inner: Self::default(),
27709            marker: ::std::marker::PhantomData,
27710        }
27711    }
27712}
27713#[repr(transparent)]
27714pub struct SubpassDependency2Builder<'a> {
27715    inner: SubpassDependency2,
27716    marker: ::std::marker::PhantomData<&'a ()>,
27717}
27718pub unsafe trait ExtendsSubpassDependency2 {}
27719impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> {
27720    type Target = SubpassDependency2;
27721    fn deref(&self) -> &Self::Target {
27722        &self.inner
27723    }
27724}
27725impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> {
27726    fn deref_mut(&mut self) -> &mut Self::Target {
27727        &mut self.inner
27728    }
27729}
27730impl<'a> SubpassDependency2Builder<'a> {
27731    pub fn src_subpass(mut self, src_subpass: u32) -> Self {
27732        self.inner.src_subpass = src_subpass;
27733        self
27734    }
27735    pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
27736        self.inner.dst_subpass = dst_subpass;
27737        self
27738    }
27739    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
27740        self.inner.src_stage_mask = src_stage_mask;
27741        self
27742    }
27743    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
27744        self.inner.dst_stage_mask = dst_stage_mask;
27745        self
27746    }
27747    pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
27748        self.inner.src_access_mask = src_access_mask;
27749        self
27750    }
27751    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
27752        self.inner.dst_access_mask = dst_access_mask;
27753        self
27754    }
27755    pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
27756        self.inner.dependency_flags = dependency_flags;
27757        self
27758    }
27759    pub fn view_offset(mut self, view_offset: i32) -> Self {
27760        self.inner.view_offset = view_offset;
27761        self
27762    }
27763    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27764    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27765    #[doc = r" valid extension structs can be pushed into the chain."]
27766    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27767    #[doc = r" chain will look like `A -> D -> B -> C`."]
27768    pub fn push_next<T: ExtendsSubpassDependency2>(mut self, next: &'a mut T) -> Self {
27769        unsafe {
27770            let next_ptr = <*const T>::cast(next);
27771            let last_next = ptr_chain_iter(next).last().unwrap();
27772            (*last_next).p_next = self.inner.p_next as _;
27773            self.inner.p_next = next_ptr;
27774        }
27775        self
27776    }
27777    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27778    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27779    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27780    pub fn build(self) -> SubpassDependency2 {
27781        self.inner
27782    }
27783}
27784#[repr(C)]
27785#[cfg_attr(feature = "debug", derive(Debug))]
27786#[derive(Copy, Clone)]
27787#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo2.html>"]
27788pub struct RenderPassCreateInfo2 {
27789    pub s_type: StructureType,
27790    pub p_next: *const c_void,
27791    pub flags: RenderPassCreateFlags,
27792    pub attachment_count: u32,
27793    pub p_attachments: *const AttachmentDescription2,
27794    pub subpass_count: u32,
27795    pub p_subpasses: *const SubpassDescription2,
27796    pub dependency_count: u32,
27797    pub p_dependencies: *const SubpassDependency2,
27798    pub correlated_view_mask_count: u32,
27799    pub p_correlated_view_masks: *const u32,
27800}
27801impl ::std::default::Default for RenderPassCreateInfo2 {
27802    fn default() -> Self {
27803        Self {
27804            s_type: StructureType::RENDER_PASS_CREATE_INFO_2,
27805            p_next: ::std::ptr::null(),
27806            flags: RenderPassCreateFlags::default(),
27807            attachment_count: u32::default(),
27808            p_attachments: ::std::ptr::null(),
27809            subpass_count: u32::default(),
27810            p_subpasses: ::std::ptr::null(),
27811            dependency_count: u32::default(),
27812            p_dependencies: ::std::ptr::null(),
27813            correlated_view_mask_count: u32::default(),
27814            p_correlated_view_masks: ::std::ptr::null(),
27815        }
27816    }
27817}
27818impl RenderPassCreateInfo2 {
27819    pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> {
27820        RenderPassCreateInfo2Builder {
27821            inner: Self::default(),
27822            marker: ::std::marker::PhantomData,
27823        }
27824    }
27825}
27826#[repr(transparent)]
27827pub struct RenderPassCreateInfo2Builder<'a> {
27828    inner: RenderPassCreateInfo2,
27829    marker: ::std::marker::PhantomData<&'a ()>,
27830}
27831pub unsafe trait ExtendsRenderPassCreateInfo2 {}
27832impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> {
27833    type Target = RenderPassCreateInfo2;
27834    fn deref(&self) -> &Self::Target {
27835        &self.inner
27836    }
27837}
27838impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> {
27839    fn deref_mut(&mut self) -> &mut Self::Target {
27840        &mut self.inner
27841    }
27842}
27843impl<'a> RenderPassCreateInfo2Builder<'a> {
27844    pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
27845        self.inner.flags = flags;
27846        self
27847    }
27848    pub fn attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self {
27849        self.inner.attachment_count = attachments.len() as _;
27850        self.inner.p_attachments = attachments.as_ptr();
27851        self
27852    }
27853    pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self {
27854        self.inner.subpass_count = subpasses.len() as _;
27855        self.inner.p_subpasses = subpasses.as_ptr();
27856        self
27857    }
27858    pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self {
27859        self.inner.dependency_count = dependencies.len() as _;
27860        self.inner.p_dependencies = dependencies.as_ptr();
27861        self
27862    }
27863    pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self {
27864        self.inner.correlated_view_mask_count = correlated_view_masks.len() as _;
27865        self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr();
27866        self
27867    }
27868    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27869    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27870    #[doc = r" valid extension structs can be pushed into the chain."]
27871    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27872    #[doc = r" chain will look like `A -> D -> B -> C`."]
27873    pub fn push_next<T: ExtendsRenderPassCreateInfo2>(mut self, next: &'a mut T) -> Self {
27874        unsafe {
27875            let next_ptr = <*const T>::cast(next);
27876            let last_next = ptr_chain_iter(next).last().unwrap();
27877            (*last_next).p_next = self.inner.p_next as _;
27878            self.inner.p_next = next_ptr;
27879        }
27880        self
27881    }
27882    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27883    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27884    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27885    pub fn build(self) -> RenderPassCreateInfo2 {
27886        self.inner
27887    }
27888}
27889#[repr(C)]
27890#[cfg_attr(feature = "debug", derive(Debug))]
27891#[derive(Copy, Clone)]
27892#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassBeginInfo.html>"]
27893pub struct SubpassBeginInfo {
27894    pub s_type: StructureType,
27895    pub p_next: *const c_void,
27896    pub contents: SubpassContents,
27897}
27898impl ::std::default::Default for SubpassBeginInfo {
27899    fn default() -> Self {
27900        Self {
27901            s_type: StructureType::SUBPASS_BEGIN_INFO,
27902            p_next: ::std::ptr::null(),
27903            contents: SubpassContents::default(),
27904        }
27905    }
27906}
27907impl SubpassBeginInfo {
27908    pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> {
27909        SubpassBeginInfoBuilder {
27910            inner: Self::default(),
27911            marker: ::std::marker::PhantomData,
27912        }
27913    }
27914}
27915#[repr(transparent)]
27916pub struct SubpassBeginInfoBuilder<'a> {
27917    inner: SubpassBeginInfo,
27918    marker: ::std::marker::PhantomData<&'a ()>,
27919}
27920impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> {
27921    type Target = SubpassBeginInfo;
27922    fn deref(&self) -> &Self::Target {
27923        &self.inner
27924    }
27925}
27926impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> {
27927    fn deref_mut(&mut self) -> &mut Self::Target {
27928        &mut self.inner
27929    }
27930}
27931impl<'a> SubpassBeginInfoBuilder<'a> {
27932    pub fn contents(mut self, contents: SubpassContents) -> Self {
27933        self.inner.contents = contents;
27934        self
27935    }
27936    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27937    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27938    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
27939    pub fn build(self) -> SubpassBeginInfo {
27940        self.inner
27941    }
27942}
27943#[repr(C)]
27944#[cfg_attr(feature = "debug", derive(Debug))]
27945#[derive(Copy, Clone)]
27946#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassEndInfo.html>"]
27947pub struct SubpassEndInfo {
27948    pub s_type: StructureType,
27949    pub p_next: *const c_void,
27950}
27951impl ::std::default::Default for SubpassEndInfo {
27952    fn default() -> Self {
27953        Self {
27954            s_type: StructureType::SUBPASS_END_INFO,
27955            p_next: ::std::ptr::null(),
27956        }
27957    }
27958}
27959impl SubpassEndInfo {
27960    pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> {
27961        SubpassEndInfoBuilder {
27962            inner: Self::default(),
27963            marker: ::std::marker::PhantomData,
27964        }
27965    }
27966}
27967#[repr(transparent)]
27968pub struct SubpassEndInfoBuilder<'a> {
27969    inner: SubpassEndInfo,
27970    marker: ::std::marker::PhantomData<&'a ()>,
27971}
27972pub unsafe trait ExtendsSubpassEndInfo {}
27973impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> {
27974    type Target = SubpassEndInfo;
27975    fn deref(&self) -> &Self::Target {
27976        &self.inner
27977    }
27978}
27979impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> {
27980    fn deref_mut(&mut self) -> &mut Self::Target {
27981        &mut self.inner
27982    }
27983}
27984impl<'a> SubpassEndInfoBuilder<'a> {
27985    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27986    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27987    #[doc = r" valid extension structs can be pushed into the chain."]
27988    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27989    #[doc = r" chain will look like `A -> D -> B -> C`."]
27990    pub fn push_next<T: ExtendsSubpassEndInfo>(mut self, next: &'a mut T) -> Self {
27991        unsafe {
27992            let next_ptr = <*const T>::cast(next);
27993            let last_next = ptr_chain_iter(next).last().unwrap();
27994            (*last_next).p_next = self.inner.p_next as _;
27995            self.inner.p_next = next_ptr;
27996        }
27997        self
27998    }
27999    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28000    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28001    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28002    pub fn build(self) -> SubpassEndInfo {
28003        self.inner
28004    }
28005}
28006#[repr(C)]
28007#[cfg_attr(feature = "debug", derive(Debug))]
28008#[derive(Copy, Clone)]
28009#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>"]
28010pub struct PhysicalDeviceTimelineSemaphoreFeatures {
28011    pub s_type: StructureType,
28012    pub p_next: *mut c_void,
28013    pub timeline_semaphore: Bool32,
28014}
28015impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures {
28016    fn default() -> Self {
28017        Self {
28018            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
28019            p_next: ::std::ptr::null_mut(),
28020            timeline_semaphore: Bool32::default(),
28021        }
28022    }
28023}
28024impl PhysicalDeviceTimelineSemaphoreFeatures {
28025    pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28026        PhysicalDeviceTimelineSemaphoreFeaturesBuilder {
28027            inner: Self::default(),
28028            marker: ::std::marker::PhantomData,
28029        }
28030    }
28031}
28032#[repr(transparent)]
28033pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28034    inner: PhysicalDeviceTimelineSemaphoreFeatures,
28035    marker: ::std::marker::PhantomData<&'a ()>,
28036}
28037unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
28038unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures {}
28039unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
28040unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {}
28041impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28042    type Target = PhysicalDeviceTimelineSemaphoreFeatures;
28043    fn deref(&self) -> &Self::Target {
28044        &self.inner
28045    }
28046}
28047impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28048    fn deref_mut(&mut self) -> &mut Self::Target {
28049        &mut self.inner
28050    }
28051}
28052impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
28053    pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
28054        self.inner.timeline_semaphore = timeline_semaphore.into();
28055        self
28056    }
28057    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28058    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28059    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28060    pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures {
28061        self.inner
28062    }
28063}
28064#[repr(C)]
28065#[cfg_attr(feature = "debug", derive(Debug))]
28066#[derive(Copy, Clone)]
28067#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>"]
28068pub struct PhysicalDeviceTimelineSemaphoreProperties {
28069    pub s_type: StructureType,
28070    pub p_next: *mut c_void,
28071    pub max_timeline_semaphore_value_difference: u64,
28072}
28073impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties {
28074    fn default() -> Self {
28075        Self {
28076            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
28077            p_next: ::std::ptr::null_mut(),
28078            max_timeline_semaphore_value_difference: u64::default(),
28079        }
28080    }
28081}
28082impl PhysicalDeviceTimelineSemaphoreProperties {
28083    pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28084        PhysicalDeviceTimelineSemaphorePropertiesBuilder {
28085            inner: Self::default(),
28086            marker: ::std::marker::PhantomData,
28087        }
28088    }
28089}
28090#[repr(transparent)]
28091pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28092    inner: PhysicalDeviceTimelineSemaphoreProperties,
28093    marker: ::std::marker::PhantomData<&'a ()>,
28094}
28095unsafe impl ExtendsPhysicalDeviceProperties2
28096    for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_>
28097{
28098}
28099unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {}
28100impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28101    type Target = PhysicalDeviceTimelineSemaphoreProperties;
28102    fn deref(&self) -> &Self::Target {
28103        &self.inner
28104    }
28105}
28106impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28107    fn deref_mut(&mut self) -> &mut Self::Target {
28108        &mut self.inner
28109    }
28110}
28111impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
28112    pub fn max_timeline_semaphore_value_difference(
28113        mut self,
28114        max_timeline_semaphore_value_difference: u64,
28115    ) -> Self {
28116        self.inner.max_timeline_semaphore_value_difference =
28117            max_timeline_semaphore_value_difference;
28118        self
28119    }
28120    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28121    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28122    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28123    pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties {
28124        self.inner
28125    }
28126}
28127#[repr(C)]
28128#[cfg_attr(feature = "debug", derive(Debug))]
28129#[derive(Copy, Clone)]
28130#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreTypeCreateInfo.html>"]
28131pub struct SemaphoreTypeCreateInfo {
28132    pub s_type: StructureType,
28133    pub p_next: *const c_void,
28134    pub semaphore_type: SemaphoreType,
28135    pub initial_value: u64,
28136}
28137impl ::std::default::Default for SemaphoreTypeCreateInfo {
28138    fn default() -> Self {
28139        Self {
28140            s_type: StructureType::SEMAPHORE_TYPE_CREATE_INFO,
28141            p_next: ::std::ptr::null(),
28142            semaphore_type: SemaphoreType::default(),
28143            initial_value: u64::default(),
28144        }
28145    }
28146}
28147impl SemaphoreTypeCreateInfo {
28148    pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> {
28149        SemaphoreTypeCreateInfoBuilder {
28150            inner: Self::default(),
28151            marker: ::std::marker::PhantomData,
28152        }
28153    }
28154}
28155#[repr(transparent)]
28156pub struct SemaphoreTypeCreateInfoBuilder<'a> {
28157    inner: SemaphoreTypeCreateInfo,
28158    marker: ::std::marker::PhantomData<&'a ()>,
28159}
28160unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
28161unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {}
28162unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
28163unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {}
28164impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> {
28165    type Target = SemaphoreTypeCreateInfo;
28166    fn deref(&self) -> &Self::Target {
28167        &self.inner
28168    }
28169}
28170impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> {
28171    fn deref_mut(&mut self) -> &mut Self::Target {
28172        &mut self.inner
28173    }
28174}
28175impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
28176    pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self {
28177        self.inner.semaphore_type = semaphore_type;
28178        self
28179    }
28180    pub fn initial_value(mut self, initial_value: u64) -> Self {
28181        self.inner.initial_value = initial_value;
28182        self
28183    }
28184    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28185    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28186    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28187    pub fn build(self) -> SemaphoreTypeCreateInfo {
28188        self.inner
28189    }
28190}
28191#[repr(C)]
28192#[cfg_attr(feature = "debug", derive(Debug))]
28193#[derive(Copy, Clone)]
28194#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html>"]
28195pub struct TimelineSemaphoreSubmitInfo {
28196    pub s_type: StructureType,
28197    pub p_next: *const c_void,
28198    pub wait_semaphore_value_count: u32,
28199    pub p_wait_semaphore_values: *const u64,
28200    pub signal_semaphore_value_count: u32,
28201    pub p_signal_semaphore_values: *const u64,
28202}
28203impl ::std::default::Default for TimelineSemaphoreSubmitInfo {
28204    fn default() -> Self {
28205        Self {
28206            s_type: StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO,
28207            p_next: ::std::ptr::null(),
28208            wait_semaphore_value_count: u32::default(),
28209            p_wait_semaphore_values: ::std::ptr::null(),
28210            signal_semaphore_value_count: u32::default(),
28211            p_signal_semaphore_values: ::std::ptr::null(),
28212        }
28213    }
28214}
28215impl TimelineSemaphoreSubmitInfo {
28216    pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> {
28217        TimelineSemaphoreSubmitInfoBuilder {
28218            inner: Self::default(),
28219            marker: ::std::marker::PhantomData,
28220        }
28221    }
28222}
28223#[repr(transparent)]
28224pub struct TimelineSemaphoreSubmitInfoBuilder<'a> {
28225    inner: TimelineSemaphoreSubmitInfo,
28226    marker: ::std::marker::PhantomData<&'a ()>,
28227}
28228unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
28229unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {}
28230unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
28231unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {}
28232impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> {
28233    type Target = TimelineSemaphoreSubmitInfo;
28234    fn deref(&self) -> &Self::Target {
28235        &self.inner
28236    }
28237}
28238impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> {
28239    fn deref_mut(&mut self) -> &mut Self::Target {
28240        &mut self.inner
28241    }
28242}
28243impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
28244    pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
28245        self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _;
28246        self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
28247        self
28248    }
28249    pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
28250        self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _;
28251        self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
28252        self
28253    }
28254    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28255    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28256    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28257    pub fn build(self) -> TimelineSemaphoreSubmitInfo {
28258        self.inner
28259    }
28260}
28261#[repr(C)]
28262#[cfg_attr(feature = "debug", derive(Debug))]
28263#[derive(Copy, Clone)]
28264#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitInfo.html>"]
28265pub struct SemaphoreWaitInfo {
28266    pub s_type: StructureType,
28267    pub p_next: *const c_void,
28268    pub flags: SemaphoreWaitFlags,
28269    pub semaphore_count: u32,
28270    pub p_semaphores: *const Semaphore,
28271    pub p_values: *const u64,
28272}
28273impl ::std::default::Default for SemaphoreWaitInfo {
28274    fn default() -> Self {
28275        Self {
28276            s_type: StructureType::SEMAPHORE_WAIT_INFO,
28277            p_next: ::std::ptr::null(),
28278            flags: SemaphoreWaitFlags::default(),
28279            semaphore_count: u32::default(),
28280            p_semaphores: ::std::ptr::null(),
28281            p_values: ::std::ptr::null(),
28282        }
28283    }
28284}
28285impl SemaphoreWaitInfo {
28286    pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> {
28287        SemaphoreWaitInfoBuilder {
28288            inner: Self::default(),
28289            marker: ::std::marker::PhantomData,
28290        }
28291    }
28292}
28293#[repr(transparent)]
28294pub struct SemaphoreWaitInfoBuilder<'a> {
28295    inner: SemaphoreWaitInfo,
28296    marker: ::std::marker::PhantomData<&'a ()>,
28297}
28298impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> {
28299    type Target = SemaphoreWaitInfo;
28300    fn deref(&self) -> &Self::Target {
28301        &self.inner
28302    }
28303}
28304impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> {
28305    fn deref_mut(&mut self) -> &mut Self::Target {
28306        &mut self.inner
28307    }
28308}
28309impl<'a> SemaphoreWaitInfoBuilder<'a> {
28310    pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self {
28311        self.inner.flags = flags;
28312        self
28313    }
28314    pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> Self {
28315        self.inner.semaphore_count = semaphores.len() as _;
28316        self.inner.p_semaphores = semaphores.as_ptr();
28317        self
28318    }
28319    pub fn values(mut self, values: &'a [u64]) -> Self {
28320        self.inner.semaphore_count = values.len() as _;
28321        self.inner.p_values = values.as_ptr();
28322        self
28323    }
28324    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28325    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28326    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28327    pub fn build(self) -> SemaphoreWaitInfo {
28328        self.inner
28329    }
28330}
28331#[repr(C)]
28332#[cfg_attr(feature = "debug", derive(Debug))]
28333#[derive(Copy, Clone)]
28334#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSignalInfo.html>"]
28335pub struct SemaphoreSignalInfo {
28336    pub s_type: StructureType,
28337    pub p_next: *const c_void,
28338    pub semaphore: Semaphore,
28339    pub value: u64,
28340}
28341impl ::std::default::Default for SemaphoreSignalInfo {
28342    fn default() -> Self {
28343        Self {
28344            s_type: StructureType::SEMAPHORE_SIGNAL_INFO,
28345            p_next: ::std::ptr::null(),
28346            semaphore: Semaphore::default(),
28347            value: u64::default(),
28348        }
28349    }
28350}
28351impl SemaphoreSignalInfo {
28352    pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> {
28353        SemaphoreSignalInfoBuilder {
28354            inner: Self::default(),
28355            marker: ::std::marker::PhantomData,
28356        }
28357    }
28358}
28359#[repr(transparent)]
28360pub struct SemaphoreSignalInfoBuilder<'a> {
28361    inner: SemaphoreSignalInfo,
28362    marker: ::std::marker::PhantomData<&'a ()>,
28363}
28364impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> {
28365    type Target = SemaphoreSignalInfo;
28366    fn deref(&self) -> &Self::Target {
28367        &self.inner
28368    }
28369}
28370impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> {
28371    fn deref_mut(&mut self) -> &mut Self::Target {
28372        &mut self.inner
28373    }
28374}
28375impl<'a> SemaphoreSignalInfoBuilder<'a> {
28376    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
28377        self.inner.semaphore = semaphore;
28378        self
28379    }
28380    pub fn value(mut self, value: u64) -> Self {
28381        self.inner.value = value;
28382        self
28383    }
28384    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28385    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28386    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28387    pub fn build(self) -> SemaphoreSignalInfo {
28388        self.inner
28389    }
28390}
28391#[repr(C)]
28392#[cfg_attr(feature = "debug", derive(Debug))]
28393#[derive(Copy, Clone, Default)]
28394#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>"]
28395pub struct VertexInputBindingDivisorDescriptionEXT {
28396    pub binding: u32,
28397    pub divisor: u32,
28398}
28399impl VertexInputBindingDivisorDescriptionEXT {
28400    pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28401        VertexInputBindingDivisorDescriptionEXTBuilder {
28402            inner: Self::default(),
28403            marker: ::std::marker::PhantomData,
28404        }
28405    }
28406}
28407#[repr(transparent)]
28408pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28409    inner: VertexInputBindingDivisorDescriptionEXT,
28410    marker: ::std::marker::PhantomData<&'a ()>,
28411}
28412impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28413    type Target = VertexInputBindingDivisorDescriptionEXT;
28414    fn deref(&self) -> &Self::Target {
28415        &self.inner
28416    }
28417}
28418impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28419    fn deref_mut(&mut self) -> &mut Self::Target {
28420        &mut self.inner
28421    }
28422}
28423impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
28424    pub fn binding(mut self, binding: u32) -> Self {
28425        self.inner.binding = binding;
28426        self
28427    }
28428    pub fn divisor(mut self, divisor: u32) -> Self {
28429        self.inner.divisor = divisor;
28430        self
28431    }
28432    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28433    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28434    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28435    pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT {
28436        self.inner
28437    }
28438}
28439#[repr(C)]
28440#[cfg_attr(feature = "debug", derive(Debug))]
28441#[derive(Copy, Clone)]
28442#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>"]
28443pub struct PipelineVertexInputDivisorStateCreateInfoEXT {
28444    pub s_type: StructureType,
28445    pub p_next: *const c_void,
28446    pub vertex_binding_divisor_count: u32,
28447    pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT,
28448}
28449impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT {
28450    fn default() -> Self {
28451        Self {
28452            s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
28453            p_next: ::std::ptr::null(),
28454            vertex_binding_divisor_count: u32::default(),
28455            p_vertex_binding_divisors: ::std::ptr::null(),
28456        }
28457    }
28458}
28459impl PipelineVertexInputDivisorStateCreateInfoEXT {
28460    pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28461        PipelineVertexInputDivisorStateCreateInfoEXTBuilder {
28462            inner: Self::default(),
28463            marker: ::std::marker::PhantomData,
28464        }
28465    }
28466}
28467#[repr(transparent)]
28468pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28469    inner: PipelineVertexInputDivisorStateCreateInfoEXT,
28470    marker: ::std::marker::PhantomData<&'a ()>,
28471}
28472unsafe impl ExtendsPipelineVertexInputStateCreateInfo
28473    for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_>
28474{
28475}
28476unsafe impl ExtendsPipelineVertexInputStateCreateInfo
28477    for PipelineVertexInputDivisorStateCreateInfoEXT
28478{
28479}
28480impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28481    type Target = PipelineVertexInputDivisorStateCreateInfoEXT;
28482    fn deref(&self) -> &Self::Target {
28483        &self.inner
28484    }
28485}
28486impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28487    fn deref_mut(&mut self) -> &mut Self::Target {
28488        &mut self.inner
28489    }
28490}
28491impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
28492    pub fn vertex_binding_divisors(
28493        mut self,
28494        vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT],
28495    ) -> Self {
28496        self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _;
28497        self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr();
28498        self
28499    }
28500    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28501    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28502    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28503    pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT {
28504        self.inner
28505    }
28506}
28507#[repr(C)]
28508#[cfg_attr(feature = "debug", derive(Debug))]
28509#[derive(Copy, Clone)]
28510#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>"]
28511pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28512    pub s_type: StructureType,
28513    pub p_next: *mut c_void,
28514    pub max_vertex_attrib_divisor: u32,
28515}
28516impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28517    fn default() -> Self {
28518        Self {
28519            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
28520            p_next: ::std::ptr::null_mut(),
28521            max_vertex_attrib_divisor: u32::default(),
28522        }
28523    }
28524}
28525impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28526    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28527        PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder {
28528            inner: Self::default(),
28529            marker: ::std::marker::PhantomData,
28530        }
28531    }
28532}
28533#[repr(transparent)]
28534pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28535    inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT,
28536    marker: ::std::marker::PhantomData<&'a ()>,
28537}
28538unsafe impl ExtendsPhysicalDeviceProperties2
28539    for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_>
28540{
28541}
28542unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {}
28543impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28544    type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
28545    fn deref(&self) -> &Self::Target {
28546        &self.inner
28547    }
28548}
28549impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28550    fn deref_mut(&mut self) -> &mut Self::Target {
28551        &mut self.inner
28552    }
28553}
28554impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
28555    pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self {
28556        self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor;
28557        self
28558    }
28559    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28560    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28561    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28562    pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
28563        self.inner
28564    }
28565}
28566#[repr(C)]
28567#[cfg_attr(feature = "debug", derive(Debug))]
28568#[derive(Copy, Clone)]
28569#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>"]
28570pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
28571    pub s_type: StructureType,
28572    pub p_next: *mut c_void,
28573    pub pci_domain: u32,
28574    pub pci_bus: u32,
28575    pub pci_device: u32,
28576    pub pci_function: u32,
28577}
28578impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT {
28579    fn default() -> Self {
28580        Self {
28581            s_type: StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
28582            p_next: ::std::ptr::null_mut(),
28583            pci_domain: u32::default(),
28584            pci_bus: u32::default(),
28585            pci_device: u32::default(),
28586            pci_function: u32::default(),
28587        }
28588    }
28589}
28590impl PhysicalDevicePCIBusInfoPropertiesEXT {
28591    pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28592        PhysicalDevicePCIBusInfoPropertiesEXTBuilder {
28593            inner: Self::default(),
28594            marker: ::std::marker::PhantomData,
28595        }
28596    }
28597}
28598#[repr(transparent)]
28599pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28600    inner: PhysicalDevicePCIBusInfoPropertiesEXT,
28601    marker: ::std::marker::PhantomData<&'a ()>,
28602}
28603unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {}
28604unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {}
28605impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28606    type Target = PhysicalDevicePCIBusInfoPropertiesEXT;
28607    fn deref(&self) -> &Self::Target {
28608        &self.inner
28609    }
28610}
28611impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28612    fn deref_mut(&mut self) -> &mut Self::Target {
28613        &mut self.inner
28614    }
28615}
28616impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
28617    pub fn pci_domain(mut self, pci_domain: u32) -> Self {
28618        self.inner.pci_domain = pci_domain;
28619        self
28620    }
28621    pub fn pci_bus(mut self, pci_bus: u32) -> Self {
28622        self.inner.pci_bus = pci_bus;
28623        self
28624    }
28625    pub fn pci_device(mut self, pci_device: u32) -> Self {
28626        self.inner.pci_device = pci_device;
28627        self
28628    }
28629    pub fn pci_function(mut self, pci_function: u32) -> Self {
28630        self.inner.pci_function = pci_function;
28631        self
28632    }
28633    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28634    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28635    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28636    pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT {
28637        self.inner
28638    }
28639}
28640#[repr(C)]
28641#[cfg_attr(feature = "debug", derive(Debug))]
28642#[derive(Copy, Clone)]
28643#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>"]
28644pub struct ImportAndroidHardwareBufferInfoANDROID {
28645    pub s_type: StructureType,
28646    pub p_next: *const c_void,
28647    pub buffer: *mut AHardwareBuffer,
28648}
28649impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID {
28650    fn default() -> Self {
28651        Self {
28652            s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
28653            p_next: ::std::ptr::null(),
28654            buffer: ::std::ptr::null_mut(),
28655        }
28656    }
28657}
28658impl ImportAndroidHardwareBufferInfoANDROID {
28659    pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28660        ImportAndroidHardwareBufferInfoANDROIDBuilder {
28661            inner: Self::default(),
28662            marker: ::std::marker::PhantomData,
28663        }
28664    }
28665}
28666#[repr(transparent)]
28667pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28668    inner: ImportAndroidHardwareBufferInfoANDROID,
28669    marker: ::std::marker::PhantomData<&'a ()>,
28670}
28671unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {}
28672unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {}
28673impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28674    type Target = ImportAndroidHardwareBufferInfoANDROID;
28675    fn deref(&self) -> &Self::Target {
28676        &self.inner
28677    }
28678}
28679impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28680    fn deref_mut(&mut self) -> &mut Self::Target {
28681        &mut self.inner
28682    }
28683}
28684impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28685    pub fn buffer(mut self, buffer: *mut AHardwareBuffer) -> Self {
28686        self.inner.buffer = buffer;
28687        self
28688    }
28689    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28690    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28691    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28692    pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID {
28693        self.inner
28694    }
28695}
28696#[repr(C)]
28697#[cfg_attr(feature = "debug", derive(Debug))]
28698#[derive(Copy, Clone)]
28699#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferUsageANDROID.html>"]
28700pub struct AndroidHardwareBufferUsageANDROID {
28701    pub s_type: StructureType,
28702    pub p_next: *mut c_void,
28703    pub android_hardware_buffer_usage: u64,
28704}
28705impl ::std::default::Default for AndroidHardwareBufferUsageANDROID {
28706    fn default() -> Self {
28707        Self {
28708            s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
28709            p_next: ::std::ptr::null_mut(),
28710            android_hardware_buffer_usage: u64::default(),
28711        }
28712    }
28713}
28714impl AndroidHardwareBufferUsageANDROID {
28715    pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28716        AndroidHardwareBufferUsageANDROIDBuilder {
28717            inner: Self::default(),
28718            marker: ::std::marker::PhantomData,
28719        }
28720    }
28721}
28722#[repr(transparent)]
28723pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28724    inner: AndroidHardwareBufferUsageANDROID,
28725    marker: ::std::marker::PhantomData<&'a ()>,
28726}
28727unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {}
28728unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {}
28729impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28730    type Target = AndroidHardwareBufferUsageANDROID;
28731    fn deref(&self) -> &Self::Target {
28732        &self.inner
28733    }
28734}
28735impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28736    fn deref_mut(&mut self) -> &mut Self::Target {
28737        &mut self.inner
28738    }
28739}
28740impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
28741    pub fn android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self {
28742        self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage;
28743        self
28744    }
28745    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28746    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28747    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28748    pub fn build(self) -> AndroidHardwareBufferUsageANDROID {
28749        self.inner
28750    }
28751}
28752#[repr(C)]
28753#[cfg_attr(feature = "debug", derive(Debug))]
28754#[derive(Copy, Clone)]
28755#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>"]
28756pub struct AndroidHardwareBufferPropertiesANDROID {
28757    pub s_type: StructureType,
28758    pub p_next: *mut c_void,
28759    pub allocation_size: DeviceSize,
28760    pub memory_type_bits: u32,
28761}
28762impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID {
28763    fn default() -> Self {
28764        Self {
28765            s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
28766            p_next: ::std::ptr::null_mut(),
28767            allocation_size: DeviceSize::default(),
28768            memory_type_bits: u32::default(),
28769        }
28770    }
28771}
28772impl AndroidHardwareBufferPropertiesANDROID {
28773    pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28774        AndroidHardwareBufferPropertiesANDROIDBuilder {
28775            inner: Self::default(),
28776            marker: ::std::marker::PhantomData,
28777        }
28778    }
28779}
28780#[repr(transparent)]
28781pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28782    inner: AndroidHardwareBufferPropertiesANDROID,
28783    marker: ::std::marker::PhantomData<&'a ()>,
28784}
28785pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {}
28786impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28787    type Target = AndroidHardwareBufferPropertiesANDROID;
28788    fn deref(&self) -> &Self::Target {
28789        &self.inner
28790    }
28791}
28792impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28793    fn deref_mut(&mut self) -> &mut Self::Target {
28794        &mut self.inner
28795    }
28796}
28797impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
28798    pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
28799        self.inner.allocation_size = allocation_size;
28800        self
28801    }
28802    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
28803        self.inner.memory_type_bits = memory_type_bits;
28804        self
28805    }
28806    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
28807    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
28808    #[doc = r" valid extension structs can be pushed into the chain."]
28809    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
28810    #[doc = r" chain will look like `A -> D -> B -> C`."]
28811    pub fn push_next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>(
28812        mut self,
28813        next: &'a mut T,
28814    ) -> Self {
28815        unsafe {
28816            let next_ptr = <*mut T>::cast(next);
28817            let last_next = ptr_chain_iter(next).last().unwrap();
28818            (*last_next).p_next = self.inner.p_next as _;
28819            self.inner.p_next = next_ptr;
28820        }
28821        self
28822    }
28823    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28824    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28825    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28826    pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID {
28827        self.inner
28828    }
28829}
28830#[repr(C)]
28831#[cfg_attr(feature = "debug", derive(Debug))]
28832#[derive(Copy, Clone)]
28833#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>"]
28834pub struct MemoryGetAndroidHardwareBufferInfoANDROID {
28835    pub s_type: StructureType,
28836    pub p_next: *const c_void,
28837    pub memory: DeviceMemory,
28838}
28839impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID {
28840    fn default() -> Self {
28841        Self {
28842            s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
28843            p_next: ::std::ptr::null(),
28844            memory: DeviceMemory::default(),
28845        }
28846    }
28847}
28848impl MemoryGetAndroidHardwareBufferInfoANDROID {
28849    pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28850        MemoryGetAndroidHardwareBufferInfoANDROIDBuilder {
28851            inner: Self::default(),
28852            marker: ::std::marker::PhantomData,
28853        }
28854    }
28855}
28856#[repr(transparent)]
28857pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28858    inner: MemoryGetAndroidHardwareBufferInfoANDROID,
28859    marker: ::std::marker::PhantomData<&'a ()>,
28860}
28861impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28862    type Target = MemoryGetAndroidHardwareBufferInfoANDROID;
28863    fn deref(&self) -> &Self::Target {
28864        &self.inner
28865    }
28866}
28867impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28868    fn deref_mut(&mut self) -> &mut Self::Target {
28869        &mut self.inner
28870    }
28871}
28872impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
28873    pub fn memory(mut self, memory: DeviceMemory) -> Self {
28874        self.inner.memory = memory;
28875        self
28876    }
28877    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28878    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28879    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28880    pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID {
28881        self.inner
28882    }
28883}
28884#[repr(C)]
28885#[cfg_attr(feature = "debug", derive(Debug))]
28886#[derive(Copy, Clone)]
28887#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>"]
28888pub struct AndroidHardwareBufferFormatPropertiesANDROID {
28889    pub s_type: StructureType,
28890    pub p_next: *mut c_void,
28891    pub format: Format,
28892    pub external_format: u64,
28893    pub format_features: FormatFeatureFlags,
28894    pub sampler_ycbcr_conversion_components: ComponentMapping,
28895    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
28896    pub suggested_ycbcr_range: SamplerYcbcrRange,
28897    pub suggested_x_chroma_offset: ChromaLocation,
28898    pub suggested_y_chroma_offset: ChromaLocation,
28899}
28900impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID {
28901    fn default() -> Self {
28902        Self {
28903            s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
28904            p_next: ::std::ptr::null_mut(),
28905            format: Format::default(),
28906            external_format: u64::default(),
28907            format_features: FormatFeatureFlags::default(),
28908            sampler_ycbcr_conversion_components: ComponentMapping::default(),
28909            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
28910            suggested_ycbcr_range: SamplerYcbcrRange::default(),
28911            suggested_x_chroma_offset: ChromaLocation::default(),
28912            suggested_y_chroma_offset: ChromaLocation::default(),
28913        }
28914    }
28915}
28916impl AndroidHardwareBufferFormatPropertiesANDROID {
28917    pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28918        AndroidHardwareBufferFormatPropertiesANDROIDBuilder {
28919            inner: Self::default(),
28920            marker: ::std::marker::PhantomData,
28921        }
28922    }
28923}
28924#[repr(transparent)]
28925pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28926    inner: AndroidHardwareBufferFormatPropertiesANDROID,
28927    marker: ::std::marker::PhantomData<&'a ()>,
28928}
28929unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
28930    for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_>
28931{
28932}
28933unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
28934    for AndroidHardwareBufferFormatPropertiesANDROID
28935{
28936}
28937impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28938    type Target = AndroidHardwareBufferFormatPropertiesANDROID;
28939    fn deref(&self) -> &Self::Target {
28940        &self.inner
28941    }
28942}
28943impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28944    fn deref_mut(&mut self) -> &mut Self::Target {
28945        &mut self.inner
28946    }
28947}
28948impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
28949    pub fn format(mut self, format: Format) -> Self {
28950        self.inner.format = format;
28951        self
28952    }
28953    pub fn external_format(mut self, external_format: u64) -> Self {
28954        self.inner.external_format = external_format;
28955        self
28956    }
28957    pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
28958        self.inner.format_features = format_features;
28959        self
28960    }
28961    pub fn sampler_ycbcr_conversion_components(
28962        mut self,
28963        sampler_ycbcr_conversion_components: ComponentMapping,
28964    ) -> Self {
28965        self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
28966        self
28967    }
28968    pub fn suggested_ycbcr_model(
28969        mut self,
28970        suggested_ycbcr_model: SamplerYcbcrModelConversion,
28971    ) -> Self {
28972        self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
28973        self
28974    }
28975    pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
28976        self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
28977        self
28978    }
28979    pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
28980        self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
28981        self
28982    }
28983    pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
28984        self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
28985        self
28986    }
28987    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28988    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28989    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
28990    pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID {
28991        self.inner
28992    }
28993}
28994#[repr(C)]
28995#[cfg_attr(feature = "debug", derive(Debug))]
28996#[derive(Copy, Clone)]
28997#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>"]
28998pub struct CommandBufferInheritanceConditionalRenderingInfoEXT {
28999    pub s_type: StructureType,
29000    pub p_next: *const c_void,
29001    pub conditional_rendering_enable: Bool32,
29002}
29003impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT {
29004    fn default() -> Self {
29005        Self {
29006            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
29007            p_next: ::std::ptr::null(),
29008            conditional_rendering_enable: Bool32::default(),
29009        }
29010    }
29011}
29012impl CommandBufferInheritanceConditionalRenderingInfoEXT {
29013    pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29014        CommandBufferInheritanceConditionalRenderingInfoEXTBuilder {
29015            inner: Self::default(),
29016            marker: ::std::marker::PhantomData,
29017        }
29018    }
29019}
29020#[repr(transparent)]
29021pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29022    inner: CommandBufferInheritanceConditionalRenderingInfoEXT,
29023    marker: ::std::marker::PhantomData<&'a ()>,
29024}
29025unsafe impl ExtendsCommandBufferInheritanceInfo
29026    for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_>
29027{
29028}
29029unsafe impl ExtendsCommandBufferInheritanceInfo
29030    for CommandBufferInheritanceConditionalRenderingInfoEXT
29031{
29032}
29033impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29034    type Target = CommandBufferInheritanceConditionalRenderingInfoEXT;
29035    fn deref(&self) -> &Self::Target {
29036        &self.inner
29037    }
29038}
29039impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29040    fn deref_mut(&mut self) -> &mut Self::Target {
29041        &mut self.inner
29042    }
29043}
29044impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
29045    pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self {
29046        self.inner.conditional_rendering_enable = conditional_rendering_enable.into();
29047        self
29048    }
29049    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29050    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29051    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29052    pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT {
29053        self.inner
29054    }
29055}
29056#[repr(C)]
29057#[cfg_attr(feature = "debug", derive(Debug))]
29058#[derive(Copy, Clone)]
29059#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFormatANDROID.html>"]
29060pub struct ExternalFormatANDROID {
29061    pub s_type: StructureType,
29062    pub p_next: *mut c_void,
29063    pub external_format: u64,
29064}
29065impl ::std::default::Default for ExternalFormatANDROID {
29066    fn default() -> Self {
29067        Self {
29068            s_type: StructureType::EXTERNAL_FORMAT_ANDROID,
29069            p_next: ::std::ptr::null_mut(),
29070            external_format: u64::default(),
29071        }
29072    }
29073}
29074impl ExternalFormatANDROID {
29075    pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> {
29076        ExternalFormatANDROIDBuilder {
29077            inner: Self::default(),
29078            marker: ::std::marker::PhantomData,
29079        }
29080    }
29081}
29082#[repr(transparent)]
29083pub struct ExternalFormatANDROIDBuilder<'a> {
29084    inner: ExternalFormatANDROID,
29085    marker: ::std::marker::PhantomData<&'a ()>,
29086}
29087unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
29088unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {}
29089unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
29090unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {}
29091impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> {
29092    type Target = ExternalFormatANDROID;
29093    fn deref(&self) -> &Self::Target {
29094        &self.inner
29095    }
29096}
29097impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> {
29098    fn deref_mut(&mut self) -> &mut Self::Target {
29099        &mut self.inner
29100    }
29101}
29102impl<'a> ExternalFormatANDROIDBuilder<'a> {
29103    pub fn external_format(mut self, external_format: u64) -> Self {
29104        self.inner.external_format = external_format;
29105        self
29106    }
29107    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29108    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29109    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29110    pub fn build(self) -> ExternalFormatANDROID {
29111        self.inner
29112    }
29113}
29114#[repr(C)]
29115#[cfg_attr(feature = "debug", derive(Debug))]
29116#[derive(Copy, Clone)]
29117#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html>"]
29118pub struct PhysicalDevice8BitStorageFeatures {
29119    pub s_type: StructureType,
29120    pub p_next: *mut c_void,
29121    pub storage_buffer8_bit_access: Bool32,
29122    pub uniform_and_storage_buffer8_bit_access: Bool32,
29123    pub storage_push_constant8: Bool32,
29124}
29125impl ::std::default::Default for PhysicalDevice8BitStorageFeatures {
29126    fn default() -> Self {
29127        Self {
29128            s_type: StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
29129            p_next: ::std::ptr::null_mut(),
29130            storage_buffer8_bit_access: Bool32::default(),
29131            uniform_and_storage_buffer8_bit_access: Bool32::default(),
29132            storage_push_constant8: Bool32::default(),
29133        }
29134    }
29135}
29136impl PhysicalDevice8BitStorageFeatures {
29137    pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29138        PhysicalDevice8BitStorageFeaturesBuilder {
29139            inner: Self::default(),
29140            marker: ::std::marker::PhantomData,
29141        }
29142    }
29143}
29144#[repr(transparent)]
29145pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29146    inner: PhysicalDevice8BitStorageFeatures,
29147    marker: ::std::marker::PhantomData<&'a ()>,
29148}
29149unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
29150unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures {}
29151unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
29152unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {}
29153impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29154    type Target = PhysicalDevice8BitStorageFeatures;
29155    fn deref(&self) -> &Self::Target {
29156        &self.inner
29157    }
29158}
29159impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29160    fn deref_mut(&mut self) -> &mut Self::Target {
29161        &mut self.inner
29162    }
29163}
29164impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
29165    pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
29166        self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
29167        self
29168    }
29169    pub fn uniform_and_storage_buffer8_bit_access(
29170        mut self,
29171        uniform_and_storage_buffer8_bit_access: bool,
29172    ) -> Self {
29173        self.inner.uniform_and_storage_buffer8_bit_access =
29174            uniform_and_storage_buffer8_bit_access.into();
29175        self
29176    }
29177    pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
29178        self.inner.storage_push_constant8 = storage_push_constant8.into();
29179        self
29180    }
29181    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29182    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29183    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29184    pub fn build(self) -> PhysicalDevice8BitStorageFeatures {
29185        self.inner
29186    }
29187}
29188#[repr(C)]
29189#[cfg_attr(feature = "debug", derive(Debug))]
29190#[derive(Copy, Clone)]
29191#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>"]
29192pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
29193    pub s_type: StructureType,
29194    pub p_next: *mut c_void,
29195    pub conditional_rendering: Bool32,
29196    pub inherited_conditional_rendering: Bool32,
29197}
29198impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT {
29199    fn default() -> Self {
29200        Self {
29201            s_type: StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
29202            p_next: ::std::ptr::null_mut(),
29203            conditional_rendering: Bool32::default(),
29204            inherited_conditional_rendering: Bool32::default(),
29205        }
29206    }
29207}
29208impl PhysicalDeviceConditionalRenderingFeaturesEXT {
29209    pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29210        PhysicalDeviceConditionalRenderingFeaturesEXTBuilder {
29211            inner: Self::default(),
29212            marker: ::std::marker::PhantomData,
29213        }
29214    }
29215}
29216#[repr(transparent)]
29217pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29218    inner: PhysicalDeviceConditionalRenderingFeaturesEXT,
29219    marker: ::std::marker::PhantomData<&'a ()>,
29220}
29221unsafe impl ExtendsPhysicalDeviceFeatures2
29222    for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_>
29223{
29224}
29225unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {}
29226unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {}
29227unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {}
29228impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29229    type Target = PhysicalDeviceConditionalRenderingFeaturesEXT;
29230    fn deref(&self) -> &Self::Target {
29231        &self.inner
29232    }
29233}
29234impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29235    fn deref_mut(&mut self) -> &mut Self::Target {
29236        &mut self.inner
29237    }
29238}
29239impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
29240    pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self {
29241        self.inner.conditional_rendering = conditional_rendering.into();
29242        self
29243    }
29244    pub fn inherited_conditional_rendering(
29245        mut self,
29246        inherited_conditional_rendering: bool,
29247    ) -> Self {
29248        self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into();
29249        self
29250    }
29251    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29252    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29253    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29254    pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT {
29255        self.inner
29256    }
29257}
29258#[repr(C)]
29259#[cfg_attr(feature = "debug", derive(Debug))]
29260#[derive(Copy, Clone)]
29261#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>"]
29262pub struct PhysicalDeviceVulkanMemoryModelFeatures {
29263    pub s_type: StructureType,
29264    pub p_next: *mut c_void,
29265    pub vulkan_memory_model: Bool32,
29266    pub vulkan_memory_model_device_scope: Bool32,
29267    pub vulkan_memory_model_availability_visibility_chains: Bool32,
29268}
29269impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures {
29270    fn default() -> Self {
29271        Self {
29272            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
29273            p_next: ::std::ptr::null_mut(),
29274            vulkan_memory_model: Bool32::default(),
29275            vulkan_memory_model_device_scope: Bool32::default(),
29276            vulkan_memory_model_availability_visibility_chains: Bool32::default(),
29277        }
29278    }
29279}
29280impl PhysicalDeviceVulkanMemoryModelFeatures {
29281    pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29282        PhysicalDeviceVulkanMemoryModelFeaturesBuilder {
29283            inner: Self::default(),
29284            marker: ::std::marker::PhantomData,
29285        }
29286    }
29287}
29288#[repr(transparent)]
29289pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29290    inner: PhysicalDeviceVulkanMemoryModelFeatures,
29291    marker: ::std::marker::PhantomData<&'a ()>,
29292}
29293unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
29294unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures {}
29295unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
29296unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {}
29297impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29298    type Target = PhysicalDeviceVulkanMemoryModelFeatures;
29299    fn deref(&self) -> &Self::Target {
29300        &self.inner
29301    }
29302}
29303impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29304    fn deref_mut(&mut self) -> &mut Self::Target {
29305        &mut self.inner
29306    }
29307}
29308impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
29309    pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
29310        self.inner.vulkan_memory_model = vulkan_memory_model.into();
29311        self
29312    }
29313    pub fn vulkan_memory_model_device_scope(
29314        mut self,
29315        vulkan_memory_model_device_scope: bool,
29316    ) -> Self {
29317        self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
29318        self
29319    }
29320    pub fn vulkan_memory_model_availability_visibility_chains(
29321        mut self,
29322        vulkan_memory_model_availability_visibility_chains: bool,
29323    ) -> Self {
29324        self.inner
29325            .vulkan_memory_model_availability_visibility_chains =
29326            vulkan_memory_model_availability_visibility_chains.into();
29327        self
29328    }
29329    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29330    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29331    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29332    pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures {
29333        self.inner
29334    }
29335}
29336#[repr(C)]
29337#[cfg_attr(feature = "debug", derive(Debug))]
29338#[derive(Copy, Clone)]
29339#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>"]
29340pub struct PhysicalDeviceShaderAtomicInt64Features {
29341    pub s_type: StructureType,
29342    pub p_next: *mut c_void,
29343    pub shader_buffer_int64_atomics: Bool32,
29344    pub shader_shared_int64_atomics: Bool32,
29345}
29346impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features {
29347    fn default() -> Self {
29348        Self {
29349            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
29350            p_next: ::std::ptr::null_mut(),
29351            shader_buffer_int64_atomics: Bool32::default(),
29352            shader_shared_int64_atomics: Bool32::default(),
29353        }
29354    }
29355}
29356impl PhysicalDeviceShaderAtomicInt64Features {
29357    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29358        PhysicalDeviceShaderAtomicInt64FeaturesBuilder {
29359            inner: Self::default(),
29360            marker: ::std::marker::PhantomData,
29361        }
29362    }
29363}
29364#[repr(transparent)]
29365pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29366    inner: PhysicalDeviceShaderAtomicInt64Features,
29367    marker: ::std::marker::PhantomData<&'a ()>,
29368}
29369unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
29370unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features {}
29371unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
29372unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {}
29373impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29374    type Target = PhysicalDeviceShaderAtomicInt64Features;
29375    fn deref(&self) -> &Self::Target {
29376        &self.inner
29377    }
29378}
29379impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29380    fn deref_mut(&mut self) -> &mut Self::Target {
29381        &mut self.inner
29382    }
29383}
29384impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
29385    pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
29386        self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
29387        self
29388    }
29389    pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
29390        self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
29391        self
29392    }
29393    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29394    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29395    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29396    pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features {
29397        self.inner
29398    }
29399}
29400#[repr(C)]
29401#[cfg_attr(feature = "debug", derive(Debug))]
29402#[derive(Copy, Clone)]
29403#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html>"]
29404pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29405    pub s_type: StructureType,
29406    pub p_next: *mut c_void,
29407    pub shader_buffer_float32_atomics: Bool32,
29408    pub shader_buffer_float32_atomic_add: Bool32,
29409    pub shader_buffer_float64_atomics: Bool32,
29410    pub shader_buffer_float64_atomic_add: Bool32,
29411    pub shader_shared_float32_atomics: Bool32,
29412    pub shader_shared_float32_atomic_add: Bool32,
29413    pub shader_shared_float64_atomics: Bool32,
29414    pub shader_shared_float64_atomic_add: Bool32,
29415    pub shader_image_float32_atomics: Bool32,
29416    pub shader_image_float32_atomic_add: Bool32,
29417    pub sparse_image_float32_atomics: Bool32,
29418    pub sparse_image_float32_atomic_add: Bool32,
29419}
29420impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29421    fn default() -> Self {
29422        Self {
29423            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
29424            p_next: ::std::ptr::null_mut(),
29425            shader_buffer_float32_atomics: Bool32::default(),
29426            shader_buffer_float32_atomic_add: Bool32::default(),
29427            shader_buffer_float64_atomics: Bool32::default(),
29428            shader_buffer_float64_atomic_add: Bool32::default(),
29429            shader_shared_float32_atomics: Bool32::default(),
29430            shader_shared_float32_atomic_add: Bool32::default(),
29431            shader_shared_float64_atomics: Bool32::default(),
29432            shader_shared_float64_atomic_add: Bool32::default(),
29433            shader_image_float32_atomics: Bool32::default(),
29434            shader_image_float32_atomic_add: Bool32::default(),
29435            sparse_image_float32_atomics: Bool32::default(),
29436            sparse_image_float32_atomic_add: Bool32::default(),
29437        }
29438    }
29439}
29440impl PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29441    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29442        PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder {
29443            inner: Self::default(),
29444            marker: ::std::marker::PhantomData,
29445        }
29446    }
29447}
29448#[repr(transparent)]
29449pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29450    inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT,
29451    marker: ::std::marker::PhantomData<&'a ()>,
29452}
29453unsafe impl ExtendsPhysicalDeviceFeatures2
29454    for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_>
29455{
29456}
29457unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT {}
29458unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {}
29459unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {}
29460impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29461    type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
29462    fn deref(&self) -> &Self::Target {
29463        &self.inner
29464    }
29465}
29466impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29467    fn deref_mut(&mut self) -> &mut Self::Target {
29468        &mut self.inner
29469    }
29470}
29471impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
29472    pub fn shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self {
29473        self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into();
29474        self
29475    }
29476    pub fn shader_buffer_float32_atomic_add(
29477        mut self,
29478        shader_buffer_float32_atomic_add: bool,
29479    ) -> Self {
29480        self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into();
29481        self
29482    }
29483    pub fn shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self {
29484        self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into();
29485        self
29486    }
29487    pub fn shader_buffer_float64_atomic_add(
29488        mut self,
29489        shader_buffer_float64_atomic_add: bool,
29490    ) -> Self {
29491        self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into();
29492        self
29493    }
29494    pub fn shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self {
29495        self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into();
29496        self
29497    }
29498    pub fn shader_shared_float32_atomic_add(
29499        mut self,
29500        shader_shared_float32_atomic_add: bool,
29501    ) -> Self {
29502        self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into();
29503        self
29504    }
29505    pub fn shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self {
29506        self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into();
29507        self
29508    }
29509    pub fn shader_shared_float64_atomic_add(
29510        mut self,
29511        shader_shared_float64_atomic_add: bool,
29512    ) -> Self {
29513        self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into();
29514        self
29515    }
29516    pub fn shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self {
29517        self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into();
29518        self
29519    }
29520    pub fn shader_image_float32_atomic_add(
29521        mut self,
29522        shader_image_float32_atomic_add: bool,
29523    ) -> Self {
29524        self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into();
29525        self
29526    }
29527    pub fn sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self {
29528        self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into();
29529        self
29530    }
29531    pub fn sparse_image_float32_atomic_add(
29532        mut self,
29533        sparse_image_float32_atomic_add: bool,
29534    ) -> Self {
29535        self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into();
29536        self
29537    }
29538    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29539    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29540    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29541    pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT {
29542        self.inner
29543    }
29544}
29545#[repr(C)]
29546#[cfg_attr(feature = "debug", derive(Debug))]
29547#[derive(Copy, Clone)]
29548#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>"]
29549pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29550    pub s_type: StructureType,
29551    pub p_next: *mut c_void,
29552    pub shader_buffer_float16_atomics: Bool32,
29553    pub shader_buffer_float16_atomic_add: Bool32,
29554    pub shader_buffer_float16_atomic_min_max: Bool32,
29555    pub shader_buffer_float32_atomic_min_max: Bool32,
29556    pub shader_buffer_float64_atomic_min_max: Bool32,
29557    pub shader_shared_float16_atomics: Bool32,
29558    pub shader_shared_float16_atomic_add: Bool32,
29559    pub shader_shared_float16_atomic_min_max: Bool32,
29560    pub shader_shared_float32_atomic_min_max: Bool32,
29561    pub shader_shared_float64_atomic_min_max: Bool32,
29562    pub shader_image_float32_atomic_min_max: Bool32,
29563    pub sparse_image_float32_atomic_min_max: Bool32,
29564}
29565impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29566    fn default() -> Self {
29567        Self {
29568            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
29569            p_next: ::std::ptr::null_mut(),
29570            shader_buffer_float16_atomics: Bool32::default(),
29571            shader_buffer_float16_atomic_add: Bool32::default(),
29572            shader_buffer_float16_atomic_min_max: Bool32::default(),
29573            shader_buffer_float32_atomic_min_max: Bool32::default(),
29574            shader_buffer_float64_atomic_min_max: Bool32::default(),
29575            shader_shared_float16_atomics: Bool32::default(),
29576            shader_shared_float16_atomic_add: Bool32::default(),
29577            shader_shared_float16_atomic_min_max: Bool32::default(),
29578            shader_shared_float32_atomic_min_max: Bool32::default(),
29579            shader_shared_float64_atomic_min_max: Bool32::default(),
29580            shader_image_float32_atomic_min_max: Bool32::default(),
29581            sparse_image_float32_atomic_min_max: Bool32::default(),
29582        }
29583    }
29584}
29585impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29586    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29587        PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder {
29588            inner: Self::default(),
29589            marker: ::std::marker::PhantomData,
29590        }
29591    }
29592}
29593#[repr(transparent)]
29594pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29595    inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
29596    marker: ::std::marker::PhantomData<&'a ()>,
29597}
29598unsafe impl ExtendsPhysicalDeviceFeatures2
29599    for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_>
29600{
29601}
29602unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
29603unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {}
29604unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
29605impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29606    type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
29607    fn deref(&self) -> &Self::Target {
29608        &self.inner
29609    }
29610}
29611impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29612    fn deref_mut(&mut self) -> &mut Self::Target {
29613        &mut self.inner
29614    }
29615}
29616impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
29617    pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self {
29618        self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into();
29619        self
29620    }
29621    pub fn shader_buffer_float16_atomic_add(
29622        mut self,
29623        shader_buffer_float16_atomic_add: bool,
29624    ) -> Self {
29625        self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into();
29626        self
29627    }
29628    pub fn shader_buffer_float16_atomic_min_max(
29629        mut self,
29630        shader_buffer_float16_atomic_min_max: bool,
29631    ) -> Self {
29632        self.inner.shader_buffer_float16_atomic_min_max =
29633            shader_buffer_float16_atomic_min_max.into();
29634        self
29635    }
29636    pub fn shader_buffer_float32_atomic_min_max(
29637        mut self,
29638        shader_buffer_float32_atomic_min_max: bool,
29639    ) -> Self {
29640        self.inner.shader_buffer_float32_atomic_min_max =
29641            shader_buffer_float32_atomic_min_max.into();
29642        self
29643    }
29644    pub fn shader_buffer_float64_atomic_min_max(
29645        mut self,
29646        shader_buffer_float64_atomic_min_max: bool,
29647    ) -> Self {
29648        self.inner.shader_buffer_float64_atomic_min_max =
29649            shader_buffer_float64_atomic_min_max.into();
29650        self
29651    }
29652    pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self {
29653        self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into();
29654        self
29655    }
29656    pub fn shader_shared_float16_atomic_add(
29657        mut self,
29658        shader_shared_float16_atomic_add: bool,
29659    ) -> Self {
29660        self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into();
29661        self
29662    }
29663    pub fn shader_shared_float16_atomic_min_max(
29664        mut self,
29665        shader_shared_float16_atomic_min_max: bool,
29666    ) -> Self {
29667        self.inner.shader_shared_float16_atomic_min_max =
29668            shader_shared_float16_atomic_min_max.into();
29669        self
29670    }
29671    pub fn shader_shared_float32_atomic_min_max(
29672        mut self,
29673        shader_shared_float32_atomic_min_max: bool,
29674    ) -> Self {
29675        self.inner.shader_shared_float32_atomic_min_max =
29676            shader_shared_float32_atomic_min_max.into();
29677        self
29678    }
29679    pub fn shader_shared_float64_atomic_min_max(
29680        mut self,
29681        shader_shared_float64_atomic_min_max: bool,
29682    ) -> Self {
29683        self.inner.shader_shared_float64_atomic_min_max =
29684            shader_shared_float64_atomic_min_max.into();
29685        self
29686    }
29687    pub fn shader_image_float32_atomic_min_max(
29688        mut self,
29689        shader_image_float32_atomic_min_max: bool,
29690    ) -> Self {
29691        self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into();
29692        self
29693    }
29694    pub fn sparse_image_float32_atomic_min_max(
29695        mut self,
29696        sparse_image_float32_atomic_min_max: bool,
29697    ) -> Self {
29698        self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into();
29699        self
29700    }
29701    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29702    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29703    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29704    pub fn build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
29705        self.inner
29706    }
29707}
29708#[repr(C)]
29709#[cfg_attr(feature = "debug", derive(Debug))]
29710#[derive(Copy, Clone)]
29711#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
29712pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29713    pub s_type: StructureType,
29714    pub p_next: *mut c_void,
29715    pub vertex_attribute_instance_rate_divisor: Bool32,
29716    pub vertex_attribute_instance_rate_zero_divisor: Bool32,
29717}
29718impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29719    fn default() -> Self {
29720        Self {
29721            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
29722            p_next: ::std::ptr::null_mut(),
29723            vertex_attribute_instance_rate_divisor: Bool32::default(),
29724            vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
29725        }
29726    }
29727}
29728impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29729    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29730        PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder {
29731            inner: Self::default(),
29732            marker: ::std::marker::PhantomData,
29733        }
29734    }
29735}
29736#[repr(transparent)]
29737pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29738    inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT,
29739    marker: ::std::marker::PhantomData<&'a ()>,
29740}
29741unsafe impl ExtendsPhysicalDeviceFeatures2
29742    for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_>
29743{
29744}
29745unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
29746unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {}
29747unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
29748impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29749    type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
29750    fn deref(&self) -> &Self::Target {
29751        &self.inner
29752    }
29753}
29754impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29755    fn deref_mut(&mut self) -> &mut Self::Target {
29756        &mut self.inner
29757    }
29758}
29759impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
29760    pub fn vertex_attribute_instance_rate_divisor(
29761        mut self,
29762        vertex_attribute_instance_rate_divisor: bool,
29763    ) -> Self {
29764        self.inner.vertex_attribute_instance_rate_divisor =
29765            vertex_attribute_instance_rate_divisor.into();
29766        self
29767    }
29768    pub fn vertex_attribute_instance_rate_zero_divisor(
29769        mut self,
29770        vertex_attribute_instance_rate_zero_divisor: bool,
29771    ) -> Self {
29772        self.inner.vertex_attribute_instance_rate_zero_divisor =
29773            vertex_attribute_instance_rate_zero_divisor.into();
29774        self
29775    }
29776    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29777    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29778    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29779    pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
29780        self.inner
29781    }
29782}
29783#[repr(C)]
29784#[cfg_attr(feature = "debug", derive(Debug))]
29785#[derive(Copy, Clone)]
29786#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html>"]
29787pub struct QueueFamilyCheckpointPropertiesNV {
29788    pub s_type: StructureType,
29789    pub p_next: *mut c_void,
29790    pub checkpoint_execution_stage_mask: PipelineStageFlags,
29791}
29792impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV {
29793    fn default() -> Self {
29794        Self {
29795            s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
29796            p_next: ::std::ptr::null_mut(),
29797            checkpoint_execution_stage_mask: PipelineStageFlags::default(),
29798        }
29799    }
29800}
29801impl QueueFamilyCheckpointPropertiesNV {
29802    pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29803        QueueFamilyCheckpointPropertiesNVBuilder {
29804            inner: Self::default(),
29805            marker: ::std::marker::PhantomData,
29806        }
29807    }
29808}
29809#[repr(transparent)]
29810pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29811    inner: QueueFamilyCheckpointPropertiesNV,
29812    marker: ::std::marker::PhantomData<&'a ()>,
29813}
29814unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {}
29815unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {}
29816impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29817    type Target = QueueFamilyCheckpointPropertiesNV;
29818    fn deref(&self) -> &Self::Target {
29819        &self.inner
29820    }
29821}
29822impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29823    fn deref_mut(&mut self) -> &mut Self::Target {
29824        &mut self.inner
29825    }
29826}
29827impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
29828    pub fn checkpoint_execution_stage_mask(
29829        mut self,
29830        checkpoint_execution_stage_mask: PipelineStageFlags,
29831    ) -> Self {
29832        self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
29833        self
29834    }
29835    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29836    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29837    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29838    pub fn build(self) -> QueueFamilyCheckpointPropertiesNV {
29839        self.inner
29840    }
29841}
29842#[repr(C)]
29843#[cfg_attr(feature = "debug", derive(Debug))]
29844#[derive(Copy, Clone)]
29845#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointDataNV.html>"]
29846pub struct CheckpointDataNV {
29847    pub s_type: StructureType,
29848    pub p_next: *mut c_void,
29849    pub stage: PipelineStageFlags,
29850    pub p_checkpoint_marker: *mut c_void,
29851}
29852impl ::std::default::Default for CheckpointDataNV {
29853    fn default() -> Self {
29854        Self {
29855            s_type: StructureType::CHECKPOINT_DATA_NV,
29856            p_next: ::std::ptr::null_mut(),
29857            stage: PipelineStageFlags::default(),
29858            p_checkpoint_marker: ::std::ptr::null_mut(),
29859        }
29860    }
29861}
29862impl CheckpointDataNV {
29863    pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> {
29864        CheckpointDataNVBuilder {
29865            inner: Self::default(),
29866            marker: ::std::marker::PhantomData,
29867        }
29868    }
29869}
29870#[repr(transparent)]
29871pub struct CheckpointDataNVBuilder<'a> {
29872    inner: CheckpointDataNV,
29873    marker: ::std::marker::PhantomData<&'a ()>,
29874}
29875impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> {
29876    type Target = CheckpointDataNV;
29877    fn deref(&self) -> &Self::Target {
29878        &self.inner
29879    }
29880}
29881impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> {
29882    fn deref_mut(&mut self) -> &mut Self::Target {
29883        &mut self.inner
29884    }
29885}
29886impl<'a> CheckpointDataNVBuilder<'a> {
29887    pub fn stage(mut self, stage: PipelineStageFlags) -> Self {
29888        self.inner.stage = stage;
29889        self
29890    }
29891    pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
29892        self.inner.p_checkpoint_marker = checkpoint_marker;
29893        self
29894    }
29895    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29896    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29897    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29898    pub fn build(self) -> CheckpointDataNV {
29899        self.inner
29900    }
29901}
29902#[repr(C)]
29903#[cfg_attr(feature = "debug", derive(Debug))]
29904#[derive(Copy, Clone)]
29905#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>"]
29906pub struct PhysicalDeviceDepthStencilResolveProperties {
29907    pub s_type: StructureType,
29908    pub p_next: *mut c_void,
29909    pub supported_depth_resolve_modes: ResolveModeFlags,
29910    pub supported_stencil_resolve_modes: ResolveModeFlags,
29911    pub independent_resolve_none: Bool32,
29912    pub independent_resolve: Bool32,
29913}
29914impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties {
29915    fn default() -> Self {
29916        Self {
29917            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
29918            p_next: ::std::ptr::null_mut(),
29919            supported_depth_resolve_modes: ResolveModeFlags::default(),
29920            supported_stencil_resolve_modes: ResolveModeFlags::default(),
29921            independent_resolve_none: Bool32::default(),
29922            independent_resolve: Bool32::default(),
29923        }
29924    }
29925}
29926impl PhysicalDeviceDepthStencilResolveProperties {
29927    pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29928        PhysicalDeviceDepthStencilResolvePropertiesBuilder {
29929            inner: Self::default(),
29930            marker: ::std::marker::PhantomData,
29931        }
29932    }
29933}
29934#[repr(transparent)]
29935pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29936    inner: PhysicalDeviceDepthStencilResolveProperties,
29937    marker: ::std::marker::PhantomData<&'a ()>,
29938}
29939unsafe impl ExtendsPhysicalDeviceProperties2
29940    for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_>
29941{
29942}
29943unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {}
29944impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29945    type Target = PhysicalDeviceDepthStencilResolveProperties;
29946    fn deref(&self) -> &Self::Target {
29947        &self.inner
29948    }
29949}
29950impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29951    fn deref_mut(&mut self) -> &mut Self::Target {
29952        &mut self.inner
29953    }
29954}
29955impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
29956    pub fn supported_depth_resolve_modes(
29957        mut self,
29958        supported_depth_resolve_modes: ResolveModeFlags,
29959    ) -> Self {
29960        self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
29961        self
29962    }
29963    pub fn supported_stencil_resolve_modes(
29964        mut self,
29965        supported_stencil_resolve_modes: ResolveModeFlags,
29966    ) -> Self {
29967        self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
29968        self
29969    }
29970    pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
29971        self.inner.independent_resolve_none = independent_resolve_none.into();
29972        self
29973    }
29974    pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
29975        self.inner.independent_resolve = independent_resolve.into();
29976        self
29977    }
29978    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29979    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29980    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
29981    pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties {
29982        self.inner
29983    }
29984}
29985#[repr(C)]
29986#[cfg_attr(feature = "debug", derive(Debug))]
29987#[derive(Copy, Clone)]
29988#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html>"]
29989pub struct SubpassDescriptionDepthStencilResolve {
29990    pub s_type: StructureType,
29991    pub p_next: *const c_void,
29992    pub depth_resolve_mode: ResolveModeFlags,
29993    pub stencil_resolve_mode: ResolveModeFlags,
29994    pub p_depth_stencil_resolve_attachment: *const AttachmentReference2,
29995}
29996impl ::std::default::Default for SubpassDescriptionDepthStencilResolve {
29997    fn default() -> Self {
29998        Self {
29999            s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
30000            p_next: ::std::ptr::null(),
30001            depth_resolve_mode: ResolveModeFlags::default(),
30002            stencil_resolve_mode: ResolveModeFlags::default(),
30003            p_depth_stencil_resolve_attachment: ::std::ptr::null(),
30004        }
30005    }
30006}
30007impl SubpassDescriptionDepthStencilResolve {
30008    pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
30009        SubpassDescriptionDepthStencilResolveBuilder {
30010            inner: Self::default(),
30011            marker: ::std::marker::PhantomData,
30012        }
30013    }
30014}
30015#[repr(transparent)]
30016pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> {
30017    inner: SubpassDescriptionDepthStencilResolve,
30018    marker: ::std::marker::PhantomData<&'a ()>,
30019}
30020unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {}
30021unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {}
30022impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> {
30023    type Target = SubpassDescriptionDepthStencilResolve;
30024    fn deref(&self) -> &Self::Target {
30025        &self.inner
30026    }
30027}
30028impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> {
30029    fn deref_mut(&mut self) -> &mut Self::Target {
30030        &mut self.inner
30031    }
30032}
30033impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
30034    pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self {
30035        self.inner.depth_resolve_mode = depth_resolve_mode;
30036        self
30037    }
30038    pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self {
30039        self.inner.stencil_resolve_mode = stencil_resolve_mode;
30040        self
30041    }
30042    pub fn depth_stencil_resolve_attachment(
30043        mut self,
30044        depth_stencil_resolve_attachment: &'a AttachmentReference2,
30045    ) -> Self {
30046        self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment;
30047        self
30048    }
30049    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30050    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30051    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30052    pub fn build(self) -> SubpassDescriptionDepthStencilResolve {
30053        self.inner
30054    }
30055}
30056#[repr(C)]
30057#[cfg_attr(feature = "debug", derive(Debug))]
30058#[derive(Copy, Clone)]
30059#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewASTCDecodeModeEXT.html>"]
30060pub struct ImageViewASTCDecodeModeEXT {
30061    pub s_type: StructureType,
30062    pub p_next: *const c_void,
30063    pub decode_mode: Format,
30064}
30065impl ::std::default::Default for ImageViewASTCDecodeModeEXT {
30066    fn default() -> Self {
30067        Self {
30068            s_type: StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
30069            p_next: ::std::ptr::null(),
30070            decode_mode: Format::default(),
30071        }
30072    }
30073}
30074impl ImageViewASTCDecodeModeEXT {
30075    pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> {
30076        ImageViewASTCDecodeModeEXTBuilder {
30077            inner: Self::default(),
30078            marker: ::std::marker::PhantomData,
30079        }
30080    }
30081}
30082#[repr(transparent)]
30083pub struct ImageViewASTCDecodeModeEXTBuilder<'a> {
30084    inner: ImageViewASTCDecodeModeEXT,
30085    marker: ::std::marker::PhantomData<&'a ()>,
30086}
30087unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {}
30088unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {}
30089impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> {
30090    type Target = ImageViewASTCDecodeModeEXT;
30091    fn deref(&self) -> &Self::Target {
30092        &self.inner
30093    }
30094}
30095impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> {
30096    fn deref_mut(&mut self) -> &mut Self::Target {
30097        &mut self.inner
30098    }
30099}
30100impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
30101    pub fn decode_mode(mut self, decode_mode: Format) -> Self {
30102        self.inner.decode_mode = decode_mode;
30103        self
30104    }
30105    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30106    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30107    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30108    pub fn build(self) -> ImageViewASTCDecodeModeEXT {
30109        self.inner
30110    }
30111}
30112#[repr(C)]
30113#[cfg_attr(feature = "debug", derive(Debug))]
30114#[derive(Copy, Clone)]
30115#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>"]
30116pub struct PhysicalDeviceASTCDecodeFeaturesEXT {
30117    pub s_type: StructureType,
30118    pub p_next: *mut c_void,
30119    pub decode_mode_shared_exponent: Bool32,
30120}
30121impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT {
30122    fn default() -> Self {
30123        Self {
30124            s_type: StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
30125            p_next: ::std::ptr::null_mut(),
30126            decode_mode_shared_exponent: Bool32::default(),
30127        }
30128    }
30129}
30130impl PhysicalDeviceASTCDecodeFeaturesEXT {
30131    pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30132        PhysicalDeviceASTCDecodeFeaturesEXTBuilder {
30133            inner: Self::default(),
30134            marker: ::std::marker::PhantomData,
30135        }
30136    }
30137}
30138#[repr(transparent)]
30139pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30140    inner: PhysicalDeviceASTCDecodeFeaturesEXT,
30141    marker: ::std::marker::PhantomData<&'a ()>,
30142}
30143unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
30144unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {}
30145unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
30146unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {}
30147impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30148    type Target = PhysicalDeviceASTCDecodeFeaturesEXT;
30149    fn deref(&self) -> &Self::Target {
30150        &self.inner
30151    }
30152}
30153impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30154    fn deref_mut(&mut self) -> &mut Self::Target {
30155        &mut self.inner
30156    }
30157}
30158impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
30159    pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self {
30160        self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into();
30161        self
30162    }
30163    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30164    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30165    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30166    pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT {
30167        self.inner
30168    }
30169}
30170#[repr(C)]
30171#[cfg_attr(feature = "debug", derive(Debug))]
30172#[derive(Copy, Clone)]
30173#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>"]
30174pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
30175    pub s_type: StructureType,
30176    pub p_next: *mut c_void,
30177    pub transform_feedback: Bool32,
30178    pub geometry_streams: Bool32,
30179}
30180impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT {
30181    fn default() -> Self {
30182        Self {
30183            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
30184            p_next: ::std::ptr::null_mut(),
30185            transform_feedback: Bool32::default(),
30186            geometry_streams: Bool32::default(),
30187        }
30188    }
30189}
30190impl PhysicalDeviceTransformFeedbackFeaturesEXT {
30191    pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30192        PhysicalDeviceTransformFeedbackFeaturesEXTBuilder {
30193            inner: Self::default(),
30194            marker: ::std::marker::PhantomData,
30195        }
30196    }
30197}
30198#[repr(transparent)]
30199pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30200    inner: PhysicalDeviceTransformFeedbackFeaturesEXT,
30201    marker: ::std::marker::PhantomData<&'a ()>,
30202}
30203unsafe impl ExtendsPhysicalDeviceFeatures2
30204    for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_>
30205{
30206}
30207unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {}
30208unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {}
30209unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {}
30210impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30211    type Target = PhysicalDeviceTransformFeedbackFeaturesEXT;
30212    fn deref(&self) -> &Self::Target {
30213        &self.inner
30214    }
30215}
30216impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30217    fn deref_mut(&mut self) -> &mut Self::Target {
30218        &mut self.inner
30219    }
30220}
30221impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
30222    pub fn transform_feedback(mut self, transform_feedback: bool) -> Self {
30223        self.inner.transform_feedback = transform_feedback.into();
30224        self
30225    }
30226    pub fn geometry_streams(mut self, geometry_streams: bool) -> Self {
30227        self.inner.geometry_streams = geometry_streams.into();
30228        self
30229    }
30230    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30231    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30232    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30233    pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT {
30234        self.inner
30235    }
30236}
30237#[repr(C)]
30238#[cfg_attr(feature = "debug", derive(Debug))]
30239#[derive(Copy, Clone)]
30240#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>"]
30241pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
30242    pub s_type: StructureType,
30243    pub p_next: *mut c_void,
30244    pub max_transform_feedback_streams: u32,
30245    pub max_transform_feedback_buffers: u32,
30246    pub max_transform_feedback_buffer_size: DeviceSize,
30247    pub max_transform_feedback_stream_data_size: u32,
30248    pub max_transform_feedback_buffer_data_size: u32,
30249    pub max_transform_feedback_buffer_data_stride: u32,
30250    pub transform_feedback_queries: Bool32,
30251    pub transform_feedback_streams_lines_triangles: Bool32,
30252    pub transform_feedback_rasterization_stream_select: Bool32,
30253    pub transform_feedback_draw: Bool32,
30254}
30255impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
30256    fn default() -> Self {
30257        Self {
30258            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
30259            p_next: ::std::ptr::null_mut(),
30260            max_transform_feedback_streams: u32::default(),
30261            max_transform_feedback_buffers: u32::default(),
30262            max_transform_feedback_buffer_size: DeviceSize::default(),
30263            max_transform_feedback_stream_data_size: u32::default(),
30264            max_transform_feedback_buffer_data_size: u32::default(),
30265            max_transform_feedback_buffer_data_stride: u32::default(),
30266            transform_feedback_queries: Bool32::default(),
30267            transform_feedback_streams_lines_triangles: Bool32::default(),
30268            transform_feedback_rasterization_stream_select: Bool32::default(),
30269            transform_feedback_draw: Bool32::default(),
30270        }
30271    }
30272}
30273impl PhysicalDeviceTransformFeedbackPropertiesEXT {
30274    pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30275        PhysicalDeviceTransformFeedbackPropertiesEXTBuilder {
30276            inner: Self::default(),
30277            marker: ::std::marker::PhantomData,
30278        }
30279    }
30280}
30281#[repr(transparent)]
30282pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30283    inner: PhysicalDeviceTransformFeedbackPropertiesEXT,
30284    marker: ::std::marker::PhantomData<&'a ()>,
30285}
30286unsafe impl ExtendsPhysicalDeviceProperties2
30287    for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_>
30288{
30289}
30290unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {}
30291impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30292    type Target = PhysicalDeviceTransformFeedbackPropertiesEXT;
30293    fn deref(&self) -> &Self::Target {
30294        &self.inner
30295    }
30296}
30297impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30298    fn deref_mut(&mut self) -> &mut Self::Target {
30299        &mut self.inner
30300    }
30301}
30302impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
30303    pub fn max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self {
30304        self.inner.max_transform_feedback_streams = max_transform_feedback_streams;
30305        self
30306    }
30307    pub fn max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self {
30308        self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers;
30309        self
30310    }
30311    pub fn max_transform_feedback_buffer_size(
30312        mut self,
30313        max_transform_feedback_buffer_size: DeviceSize,
30314    ) -> Self {
30315        self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size;
30316        self
30317    }
30318    pub fn max_transform_feedback_stream_data_size(
30319        mut self,
30320        max_transform_feedback_stream_data_size: u32,
30321    ) -> Self {
30322        self.inner.max_transform_feedback_stream_data_size =
30323            max_transform_feedback_stream_data_size;
30324        self
30325    }
30326    pub fn max_transform_feedback_buffer_data_size(
30327        mut self,
30328        max_transform_feedback_buffer_data_size: u32,
30329    ) -> Self {
30330        self.inner.max_transform_feedback_buffer_data_size =
30331            max_transform_feedback_buffer_data_size;
30332        self
30333    }
30334    pub fn max_transform_feedback_buffer_data_stride(
30335        mut self,
30336        max_transform_feedback_buffer_data_stride: u32,
30337    ) -> Self {
30338        self.inner.max_transform_feedback_buffer_data_stride =
30339            max_transform_feedback_buffer_data_stride;
30340        self
30341    }
30342    pub fn transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self {
30343        self.inner.transform_feedback_queries = transform_feedback_queries.into();
30344        self
30345    }
30346    pub fn transform_feedback_streams_lines_triangles(
30347        mut self,
30348        transform_feedback_streams_lines_triangles: bool,
30349    ) -> Self {
30350        self.inner.transform_feedback_streams_lines_triangles =
30351            transform_feedback_streams_lines_triangles.into();
30352        self
30353    }
30354    pub fn transform_feedback_rasterization_stream_select(
30355        mut self,
30356        transform_feedback_rasterization_stream_select: bool,
30357    ) -> Self {
30358        self.inner.transform_feedback_rasterization_stream_select =
30359            transform_feedback_rasterization_stream_select.into();
30360        self
30361    }
30362    pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self {
30363        self.inner.transform_feedback_draw = transform_feedback_draw.into();
30364        self
30365    }
30366    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30367    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30368    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30369    pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT {
30370        self.inner
30371    }
30372}
30373#[repr(C)]
30374#[cfg_attr(feature = "debug", derive(Debug))]
30375#[derive(Copy, Clone)]
30376#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>"]
30377pub struct PipelineRasterizationStateStreamCreateInfoEXT {
30378    pub s_type: StructureType,
30379    pub p_next: *const c_void,
30380    pub flags: PipelineRasterizationStateStreamCreateFlagsEXT,
30381    pub rasterization_stream: u32,
30382}
30383impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT {
30384    fn default() -> Self {
30385        Self {
30386            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
30387            p_next: ::std::ptr::null(),
30388            flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(),
30389            rasterization_stream: u32::default(),
30390        }
30391    }
30392}
30393impl PipelineRasterizationStateStreamCreateInfoEXT {
30394    pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30395        PipelineRasterizationStateStreamCreateInfoEXTBuilder {
30396            inner: Self::default(),
30397            marker: ::std::marker::PhantomData,
30398        }
30399    }
30400}
30401#[repr(transparent)]
30402pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30403    inner: PipelineRasterizationStateStreamCreateInfoEXT,
30404    marker: ::std::marker::PhantomData<&'a ()>,
30405}
30406unsafe impl ExtendsPipelineRasterizationStateCreateInfo
30407    for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_>
30408{
30409}
30410unsafe impl ExtendsPipelineRasterizationStateCreateInfo
30411    for PipelineRasterizationStateStreamCreateInfoEXT
30412{
30413}
30414impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30415    type Target = PipelineRasterizationStateStreamCreateInfoEXT;
30416    fn deref(&self) -> &Self::Target {
30417        &self.inner
30418    }
30419}
30420impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30421    fn deref_mut(&mut self) -> &mut Self::Target {
30422        &mut self.inner
30423    }
30424}
30425impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
30426    pub fn flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self {
30427        self.inner.flags = flags;
30428        self
30429    }
30430    pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self {
30431        self.inner.rasterization_stream = rasterization_stream;
30432        self
30433    }
30434    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30435    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30436    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30437    pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT {
30438        self.inner
30439    }
30440}
30441#[repr(C)]
30442#[cfg_attr(feature = "debug", derive(Debug))]
30443#[derive(Copy, Clone)]
30444#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>"]
30445pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30446    pub s_type: StructureType,
30447    pub p_next: *mut c_void,
30448    pub representative_fragment_test: Bool32,
30449}
30450impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30451    fn default() -> Self {
30452        Self {
30453            s_type: StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
30454            p_next: ::std::ptr::null_mut(),
30455            representative_fragment_test: Bool32::default(),
30456        }
30457    }
30458}
30459impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30460    pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30461        PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder {
30462            inner: Self::default(),
30463            marker: ::std::marker::PhantomData,
30464        }
30465    }
30466}
30467#[repr(transparent)]
30468pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30469    inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
30470    marker: ::std::marker::PhantomData<&'a ()>,
30471}
30472unsafe impl ExtendsPhysicalDeviceFeatures2
30473    for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
30474{
30475}
30476unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
30477unsafe impl ExtendsDeviceCreateInfo
30478    for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
30479{
30480}
30481unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
30482impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30483    type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
30484    fn deref(&self) -> &Self::Target {
30485        &self.inner
30486    }
30487}
30488impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30489    fn deref_mut(&mut self) -> &mut Self::Target {
30490        &mut self.inner
30491    }
30492}
30493impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
30494    pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self {
30495        self.inner.representative_fragment_test = representative_fragment_test.into();
30496        self
30497    }
30498    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30499    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30500    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30501    pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
30502        self.inner
30503    }
30504}
30505#[repr(C)]
30506#[cfg_attr(feature = "debug", derive(Debug))]
30507#[derive(Copy, Clone)]
30508#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>"]
30509pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
30510    pub s_type: StructureType,
30511    pub p_next: *const c_void,
30512    pub representative_fragment_test_enable: Bool32,
30513}
30514impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV {
30515    fn default() -> Self {
30516        Self {
30517            s_type: StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
30518            p_next: ::std::ptr::null(),
30519            representative_fragment_test_enable: Bool32::default(),
30520        }
30521    }
30522}
30523impl PipelineRepresentativeFragmentTestStateCreateInfoNV {
30524    pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30525        PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder {
30526            inner: Self::default(),
30527            marker: ::std::marker::PhantomData,
30528        }
30529    }
30530}
30531#[repr(transparent)]
30532pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30533    inner: PipelineRepresentativeFragmentTestStateCreateInfoNV,
30534    marker: ::std::marker::PhantomData<&'a ()>,
30535}
30536unsafe impl ExtendsGraphicsPipelineCreateInfo
30537    for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_>
30538{
30539}
30540unsafe impl ExtendsGraphicsPipelineCreateInfo
30541    for PipelineRepresentativeFragmentTestStateCreateInfoNV
30542{
30543}
30544impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30545    type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV;
30546    fn deref(&self) -> &Self::Target {
30547        &self.inner
30548    }
30549}
30550impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30551    fn deref_mut(&mut self) -> &mut Self::Target {
30552        &mut self.inner
30553    }
30554}
30555impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
30556    pub fn representative_fragment_test_enable(
30557        mut self,
30558        representative_fragment_test_enable: bool,
30559    ) -> Self {
30560        self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into();
30561        self
30562    }
30563    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30564    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30565    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30566    pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
30567        self.inner
30568    }
30569}
30570#[repr(C)]
30571#[cfg_attr(feature = "debug", derive(Debug))]
30572#[derive(Copy, Clone)]
30573#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>"]
30574pub struct PhysicalDeviceExclusiveScissorFeaturesNV {
30575    pub s_type: StructureType,
30576    pub p_next: *mut c_void,
30577    pub exclusive_scissor: Bool32,
30578}
30579impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV {
30580    fn default() -> Self {
30581        Self {
30582            s_type: StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
30583            p_next: ::std::ptr::null_mut(),
30584            exclusive_scissor: Bool32::default(),
30585        }
30586    }
30587}
30588impl PhysicalDeviceExclusiveScissorFeaturesNV {
30589    pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30590        PhysicalDeviceExclusiveScissorFeaturesNVBuilder {
30591            inner: Self::default(),
30592            marker: ::std::marker::PhantomData,
30593        }
30594    }
30595}
30596#[repr(transparent)]
30597pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30598    inner: PhysicalDeviceExclusiveScissorFeaturesNV,
30599    marker: ::std::marker::PhantomData<&'a ()>,
30600}
30601unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
30602unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {}
30603unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
30604unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {}
30605impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30606    type Target = PhysicalDeviceExclusiveScissorFeaturesNV;
30607    fn deref(&self) -> &Self::Target {
30608        &self.inner
30609    }
30610}
30611impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30612    fn deref_mut(&mut self) -> &mut Self::Target {
30613        &mut self.inner
30614    }
30615}
30616impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
30617    pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self {
30618        self.inner.exclusive_scissor = exclusive_scissor.into();
30619        self
30620    }
30621    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30622    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30623    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30624    pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV {
30625        self.inner
30626    }
30627}
30628#[repr(C)]
30629#[cfg_attr(feature = "debug", derive(Debug))]
30630#[derive(Copy, Clone)]
30631#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>"]
30632pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
30633    pub s_type: StructureType,
30634    pub p_next: *const c_void,
30635    pub exclusive_scissor_count: u32,
30636    pub p_exclusive_scissors: *const Rect2D,
30637}
30638impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV {
30639    fn default() -> Self {
30640        Self {
30641            s_type: StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
30642            p_next: ::std::ptr::null(),
30643            exclusive_scissor_count: u32::default(),
30644            p_exclusive_scissors: ::std::ptr::null(),
30645        }
30646    }
30647}
30648impl PipelineViewportExclusiveScissorStateCreateInfoNV {
30649    pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30650        PipelineViewportExclusiveScissorStateCreateInfoNVBuilder {
30651            inner: Self::default(),
30652            marker: ::std::marker::PhantomData,
30653        }
30654    }
30655}
30656#[repr(transparent)]
30657pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30658    inner: PipelineViewportExclusiveScissorStateCreateInfoNV,
30659    marker: ::std::marker::PhantomData<&'a ()>,
30660}
30661unsafe impl ExtendsPipelineViewportStateCreateInfo
30662    for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_>
30663{
30664}
30665unsafe impl ExtendsPipelineViewportStateCreateInfo
30666    for PipelineViewportExclusiveScissorStateCreateInfoNV
30667{
30668}
30669impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30670    type Target = PipelineViewportExclusiveScissorStateCreateInfoNV;
30671    fn deref(&self) -> &Self::Target {
30672        &self.inner
30673    }
30674}
30675impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30676    fn deref_mut(&mut self) -> &mut Self::Target {
30677        &mut self.inner
30678    }
30679}
30680impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
30681    pub fn exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self {
30682        self.inner.exclusive_scissor_count = exclusive_scissors.len() as _;
30683        self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr();
30684        self
30685    }
30686    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30687    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30688    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30689    pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV {
30690        self.inner
30691    }
30692}
30693#[repr(C)]
30694#[cfg_attr(feature = "debug", derive(Debug))]
30695#[derive(Copy, Clone)]
30696#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>"]
30697pub struct PhysicalDeviceCornerSampledImageFeaturesNV {
30698    pub s_type: StructureType,
30699    pub p_next: *mut c_void,
30700    pub corner_sampled_image: Bool32,
30701}
30702impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV {
30703    fn default() -> Self {
30704        Self {
30705            s_type: StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
30706            p_next: ::std::ptr::null_mut(),
30707            corner_sampled_image: Bool32::default(),
30708        }
30709    }
30710}
30711impl PhysicalDeviceCornerSampledImageFeaturesNV {
30712    pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30713        PhysicalDeviceCornerSampledImageFeaturesNVBuilder {
30714            inner: Self::default(),
30715            marker: ::std::marker::PhantomData,
30716        }
30717    }
30718}
30719#[repr(transparent)]
30720pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30721    inner: PhysicalDeviceCornerSampledImageFeaturesNV,
30722    marker: ::std::marker::PhantomData<&'a ()>,
30723}
30724unsafe impl ExtendsPhysicalDeviceFeatures2
30725    for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_>
30726{
30727}
30728unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {}
30729unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {}
30730unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {}
30731impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30732    type Target = PhysicalDeviceCornerSampledImageFeaturesNV;
30733    fn deref(&self) -> &Self::Target {
30734        &self.inner
30735    }
30736}
30737impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30738    fn deref_mut(&mut self) -> &mut Self::Target {
30739        &mut self.inner
30740    }
30741}
30742impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
30743    pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self {
30744        self.inner.corner_sampled_image = corner_sampled_image.into();
30745        self
30746    }
30747    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30748    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30749    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30750    pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV {
30751        self.inner
30752    }
30753}
30754#[repr(C)]
30755#[cfg_attr(feature = "debug", derive(Debug))]
30756#[derive(Copy, Clone)]
30757#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>"]
30758pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30759    pub s_type: StructureType,
30760    pub p_next: *mut c_void,
30761    pub compute_derivative_group_quads: Bool32,
30762    pub compute_derivative_group_linear: Bool32,
30763}
30764impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30765    fn default() -> Self {
30766        Self {
30767            s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
30768            p_next: ::std::ptr::null_mut(),
30769            compute_derivative_group_quads: Bool32::default(),
30770            compute_derivative_group_linear: Bool32::default(),
30771        }
30772    }
30773}
30774impl PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30775    pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30776        PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder {
30777            inner: Self::default(),
30778            marker: ::std::marker::PhantomData,
30779        }
30780    }
30781}
30782#[repr(transparent)]
30783pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30784    inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV,
30785    marker: ::std::marker::PhantomData<&'a ()>,
30786}
30787unsafe impl ExtendsPhysicalDeviceFeatures2
30788    for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
30789{
30790}
30791unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
30792unsafe impl ExtendsDeviceCreateInfo
30793    for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
30794{
30795}
30796unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
30797impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30798    type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
30799    fn deref(&self) -> &Self::Target {
30800        &self.inner
30801    }
30802}
30803impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30804    fn deref_mut(&mut self) -> &mut Self::Target {
30805        &mut self.inner
30806    }
30807}
30808impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
30809    pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self {
30810        self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into();
30811        self
30812    }
30813    pub fn compute_derivative_group_linear(
30814        mut self,
30815        compute_derivative_group_linear: bool,
30816    ) -> Self {
30817        self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into();
30818        self
30819    }
30820    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30821    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30822    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30823    pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
30824        self.inner
30825    }
30826}
30827#[repr(C)]
30828#[cfg_attr(feature = "debug", derive(Debug))]
30829#[derive(Copy, Clone)]
30830#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html>"]
30831pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30832    pub s_type: StructureType,
30833    pub p_next: *mut c_void,
30834    pub fragment_shader_barycentric: Bool32,
30835}
30836impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30837    fn default() -> Self {
30838        Self {
30839            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
30840            p_next: ::std::ptr::null_mut(),
30841            fragment_shader_barycentric: Bool32::default(),
30842        }
30843    }
30844}
30845impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30846    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30847        PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder {
30848            inner: Self::default(),
30849            marker: ::std::marker::PhantomData,
30850        }
30851    }
30852}
30853#[repr(transparent)]
30854pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30855    inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV,
30856    marker: ::std::marker::PhantomData<&'a ()>,
30857}
30858unsafe impl ExtendsPhysicalDeviceFeatures2
30859    for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
30860{
30861}
30862unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
30863unsafe impl ExtendsDeviceCreateInfo
30864    for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
30865{
30866}
30867unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
30868impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30869    type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
30870    fn deref(&self) -> &Self::Target {
30871        &self.inner
30872    }
30873}
30874impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30875    fn deref_mut(&mut self) -> &mut Self::Target {
30876        &mut self.inner
30877    }
30878}
30879impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
30880    pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self {
30881        self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into();
30882        self
30883    }
30884    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30885    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30886    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30887    pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
30888        self.inner
30889    }
30890}
30891#[repr(C)]
30892#[cfg_attr(feature = "debug", derive(Debug))]
30893#[derive(Copy, Clone)]
30894#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>"]
30895pub struct PhysicalDeviceShaderImageFootprintFeaturesNV {
30896    pub s_type: StructureType,
30897    pub p_next: *mut c_void,
30898    pub image_footprint: Bool32,
30899}
30900impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV {
30901    fn default() -> Self {
30902        Self {
30903            s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
30904            p_next: ::std::ptr::null_mut(),
30905            image_footprint: Bool32::default(),
30906        }
30907    }
30908}
30909impl PhysicalDeviceShaderImageFootprintFeaturesNV {
30910    pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30911        PhysicalDeviceShaderImageFootprintFeaturesNVBuilder {
30912            inner: Self::default(),
30913            marker: ::std::marker::PhantomData,
30914        }
30915    }
30916}
30917#[repr(transparent)]
30918pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30919    inner: PhysicalDeviceShaderImageFootprintFeaturesNV,
30920    marker: ::std::marker::PhantomData<&'a ()>,
30921}
30922unsafe impl ExtendsPhysicalDeviceFeatures2
30923    for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_>
30924{
30925}
30926unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {}
30927unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {}
30928unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {}
30929impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30930    type Target = PhysicalDeviceShaderImageFootprintFeaturesNV;
30931    fn deref(&self) -> &Self::Target {
30932        &self.inner
30933    }
30934}
30935impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30936    fn deref_mut(&mut self) -> &mut Self::Target {
30937        &mut self.inner
30938    }
30939}
30940impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
30941    pub fn image_footprint(mut self, image_footprint: bool) -> Self {
30942        self.inner.image_footprint = image_footprint.into();
30943        self
30944    }
30945    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30946    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30947    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
30948    pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV {
30949        self.inner
30950    }
30951}
30952#[repr(C)]
30953#[cfg_attr(feature = "debug", derive(Debug))]
30954#[derive(Copy, Clone)]
30955#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>"]
30956pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
30957    pub s_type: StructureType,
30958    pub p_next: *mut c_void,
30959    pub dedicated_allocation_image_aliasing: Bool32,
30960}
30961impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
30962    fn default() -> Self {
30963        Self {
30964            s_type: StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
30965            p_next: ::std::ptr::null_mut(),
30966            dedicated_allocation_image_aliasing: Bool32::default(),
30967        }
30968    }
30969}
30970impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
30971    pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
30972        PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder {
30973            inner: Self::default(),
30974            marker: ::std::marker::PhantomData,
30975        }
30976    }
30977}
30978#[repr(transparent)]
30979pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
30980    inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
30981    marker: ::std::marker::PhantomData<&'a ()>,
30982}
30983unsafe impl ExtendsPhysicalDeviceFeatures2
30984    for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
30985{
30986}
30987unsafe impl ExtendsPhysicalDeviceFeatures2
30988    for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
30989{
30990}
30991unsafe impl ExtendsDeviceCreateInfo
30992    for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
30993{
30994}
30995unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {}
30996impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
30997    type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
30998    fn deref(&self) -> &Self::Target {
30999        &self.inner
31000    }
31001}
31002impl<'a> ::std::ops::DerefMut
31003    for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>
31004{
31005    fn deref_mut(&mut self) -> &mut Self::Target {
31006        &mut self.inner
31007    }
31008}
31009impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
31010    pub fn dedicated_allocation_image_aliasing(
31011        mut self,
31012        dedicated_allocation_image_aliasing: bool,
31013    ) -> Self {
31014        self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into();
31015        self
31016    }
31017    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31018    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31019    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31020    pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
31021        self.inner
31022    }
31023}
31024#[repr(C)]
31025#[cfg_attr(feature = "debug", derive(Debug))]
31026#[derive(Copy, Clone)]
31027#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShadingRatePaletteNV.html>"]
31028pub struct ShadingRatePaletteNV {
31029    pub shading_rate_palette_entry_count: u32,
31030    pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
31031}
31032impl ::std::default::Default for ShadingRatePaletteNV {
31033    fn default() -> Self {
31034        Self {
31035            shading_rate_palette_entry_count: u32::default(),
31036            p_shading_rate_palette_entries: ::std::ptr::null(),
31037        }
31038    }
31039}
31040impl ShadingRatePaletteNV {
31041    pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> {
31042        ShadingRatePaletteNVBuilder {
31043            inner: Self::default(),
31044            marker: ::std::marker::PhantomData,
31045        }
31046    }
31047}
31048#[repr(transparent)]
31049pub struct ShadingRatePaletteNVBuilder<'a> {
31050    inner: ShadingRatePaletteNV,
31051    marker: ::std::marker::PhantomData<&'a ()>,
31052}
31053impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> {
31054    type Target = ShadingRatePaletteNV;
31055    fn deref(&self) -> &Self::Target {
31056        &self.inner
31057    }
31058}
31059impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> {
31060    fn deref_mut(&mut self) -> &mut Self::Target {
31061        &mut self.inner
31062    }
31063}
31064impl<'a> ShadingRatePaletteNVBuilder<'a> {
31065    pub fn shading_rate_palette_entries(
31066        mut self,
31067        shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV],
31068    ) -> Self {
31069        self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _;
31070        self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr();
31071        self
31072    }
31073    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31074    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31075    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31076    pub fn build(self) -> ShadingRatePaletteNV {
31077        self.inner
31078    }
31079}
31080#[repr(C)]
31081#[cfg_attr(feature = "debug", derive(Debug))]
31082#[derive(Copy, Clone)]
31083#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>"]
31084pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
31085    pub s_type: StructureType,
31086    pub p_next: *const c_void,
31087    pub shading_rate_image_enable: Bool32,
31088    pub viewport_count: u32,
31089    pub p_shading_rate_palettes: *const ShadingRatePaletteNV,
31090}
31091impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV {
31092    fn default() -> Self {
31093        Self {
31094            s_type: StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
31095            p_next: ::std::ptr::null(),
31096            shading_rate_image_enable: Bool32::default(),
31097            viewport_count: u32::default(),
31098            p_shading_rate_palettes: ::std::ptr::null(),
31099        }
31100    }
31101}
31102impl PipelineViewportShadingRateImageStateCreateInfoNV {
31103    pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31104        PipelineViewportShadingRateImageStateCreateInfoNVBuilder {
31105            inner: Self::default(),
31106            marker: ::std::marker::PhantomData,
31107        }
31108    }
31109}
31110#[repr(transparent)]
31111pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31112    inner: PipelineViewportShadingRateImageStateCreateInfoNV,
31113    marker: ::std::marker::PhantomData<&'a ()>,
31114}
31115unsafe impl ExtendsPipelineViewportStateCreateInfo
31116    for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_>
31117{
31118}
31119unsafe impl ExtendsPipelineViewportStateCreateInfo
31120    for PipelineViewportShadingRateImageStateCreateInfoNV
31121{
31122}
31123impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31124    type Target = PipelineViewportShadingRateImageStateCreateInfoNV;
31125    fn deref(&self) -> &Self::Target {
31126        &self.inner
31127    }
31128}
31129impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31130    fn deref_mut(&mut self) -> &mut Self::Target {
31131        &mut self.inner
31132    }
31133}
31134impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
31135    pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self {
31136        self.inner.shading_rate_image_enable = shading_rate_image_enable.into();
31137        self
31138    }
31139    pub fn shading_rate_palettes(
31140        mut self,
31141        shading_rate_palettes: &'a [ShadingRatePaletteNV],
31142    ) -> Self {
31143        self.inner.viewport_count = shading_rate_palettes.len() as _;
31144        self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr();
31145        self
31146    }
31147    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31148    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31149    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31150    pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV {
31151        self.inner
31152    }
31153}
31154#[repr(C)]
31155#[cfg_attr(feature = "debug", derive(Debug))]
31156#[derive(Copy, Clone)]
31157#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>"]
31158pub struct PhysicalDeviceShadingRateImageFeaturesNV {
31159    pub s_type: StructureType,
31160    pub p_next: *mut c_void,
31161    pub shading_rate_image: Bool32,
31162    pub shading_rate_coarse_sample_order: Bool32,
31163}
31164impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV {
31165    fn default() -> Self {
31166        Self {
31167            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
31168            p_next: ::std::ptr::null_mut(),
31169            shading_rate_image: Bool32::default(),
31170            shading_rate_coarse_sample_order: Bool32::default(),
31171        }
31172    }
31173}
31174impl PhysicalDeviceShadingRateImageFeaturesNV {
31175    pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31176        PhysicalDeviceShadingRateImageFeaturesNVBuilder {
31177            inner: Self::default(),
31178            marker: ::std::marker::PhantomData,
31179        }
31180    }
31181}
31182#[repr(transparent)]
31183pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31184    inner: PhysicalDeviceShadingRateImageFeaturesNV,
31185    marker: ::std::marker::PhantomData<&'a ()>,
31186}
31187unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
31188unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {}
31189unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
31190unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {}
31191impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31192    type Target = PhysicalDeviceShadingRateImageFeaturesNV;
31193    fn deref(&self) -> &Self::Target {
31194        &self.inner
31195    }
31196}
31197impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31198    fn deref_mut(&mut self) -> &mut Self::Target {
31199        &mut self.inner
31200    }
31201}
31202impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
31203    pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self {
31204        self.inner.shading_rate_image = shading_rate_image.into();
31205        self
31206    }
31207    pub fn shading_rate_coarse_sample_order(
31208        mut self,
31209        shading_rate_coarse_sample_order: bool,
31210    ) -> Self {
31211        self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into();
31212        self
31213    }
31214    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31215    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31216    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31217    pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV {
31218        self.inner
31219    }
31220}
31221#[repr(C)]
31222#[cfg_attr(feature = "debug", derive(Debug))]
31223#[derive(Copy, Clone)]
31224#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>"]
31225pub struct PhysicalDeviceShadingRateImagePropertiesNV {
31226    pub s_type: StructureType,
31227    pub p_next: *mut c_void,
31228    pub shading_rate_texel_size: Extent2D,
31229    pub shading_rate_palette_size: u32,
31230    pub shading_rate_max_coarse_samples: u32,
31231}
31232impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV {
31233    fn default() -> Self {
31234        Self {
31235            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
31236            p_next: ::std::ptr::null_mut(),
31237            shading_rate_texel_size: Extent2D::default(),
31238            shading_rate_palette_size: u32::default(),
31239            shading_rate_max_coarse_samples: u32::default(),
31240        }
31241    }
31242}
31243impl PhysicalDeviceShadingRateImagePropertiesNV {
31244    pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31245        PhysicalDeviceShadingRateImagePropertiesNVBuilder {
31246            inner: Self::default(),
31247            marker: ::std::marker::PhantomData,
31248        }
31249    }
31250}
31251#[repr(transparent)]
31252pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31253    inner: PhysicalDeviceShadingRateImagePropertiesNV,
31254    marker: ::std::marker::PhantomData<&'a ()>,
31255}
31256unsafe impl ExtendsPhysicalDeviceProperties2
31257    for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_>
31258{
31259}
31260unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {}
31261impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31262    type Target = PhysicalDeviceShadingRateImagePropertiesNV;
31263    fn deref(&self) -> &Self::Target {
31264        &self.inner
31265    }
31266}
31267impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31268    fn deref_mut(&mut self) -> &mut Self::Target {
31269        &mut self.inner
31270    }
31271}
31272impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
31273    pub fn shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self {
31274        self.inner.shading_rate_texel_size = shading_rate_texel_size;
31275        self
31276    }
31277    pub fn shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self {
31278        self.inner.shading_rate_palette_size = shading_rate_palette_size;
31279        self
31280    }
31281    pub fn shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self {
31282        self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples;
31283        self
31284    }
31285    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31286    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31287    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31288    pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV {
31289        self.inner
31290    }
31291}
31292#[repr(C)]
31293#[cfg_attr(feature = "debug", derive(Debug))]
31294#[derive(Copy, Clone)]
31295#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>"]
31296pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31297    pub s_type: StructureType,
31298    pub p_next: *mut c_void,
31299    pub invocation_mask: Bool32,
31300}
31301impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31302    fn default() -> Self {
31303        Self {
31304            s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI,
31305            p_next: ::std::ptr::null_mut(),
31306            invocation_mask: Bool32::default(),
31307        }
31308    }
31309}
31310impl PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31311    pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31312        PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder {
31313            inner: Self::default(),
31314            marker: ::std::marker::PhantomData,
31315        }
31316    }
31317}
31318#[repr(transparent)]
31319pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31320    inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI,
31321    marker: ::std::marker::PhantomData<&'a ()>,
31322}
31323unsafe impl ExtendsPhysicalDeviceFeatures2
31324    for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_>
31325{
31326}
31327unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
31328unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {}
31329unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
31330impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31331    type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
31332    fn deref(&self) -> &Self::Target {
31333        &self.inner
31334    }
31335}
31336impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31337    fn deref_mut(&mut self) -> &mut Self::Target {
31338        &mut self.inner
31339    }
31340}
31341impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
31342    pub fn invocation_mask(mut self, invocation_mask: bool) -> Self {
31343        self.inner.invocation_mask = invocation_mask.into();
31344        self
31345    }
31346    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31347    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31348    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31349    pub fn build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
31350        self.inner
31351    }
31352}
31353#[repr(C)]
31354#[cfg_attr(feature = "debug", derive(Debug))]
31355#[derive(Copy, Clone, Default)]
31356#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleLocationNV.html>"]
31357pub struct CoarseSampleLocationNV {
31358    pub pixel_x: u32,
31359    pub pixel_y: u32,
31360    pub sample: u32,
31361}
31362impl CoarseSampleLocationNV {
31363    pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> {
31364        CoarseSampleLocationNVBuilder {
31365            inner: Self::default(),
31366            marker: ::std::marker::PhantomData,
31367        }
31368    }
31369}
31370#[repr(transparent)]
31371pub struct CoarseSampleLocationNVBuilder<'a> {
31372    inner: CoarseSampleLocationNV,
31373    marker: ::std::marker::PhantomData<&'a ()>,
31374}
31375impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> {
31376    type Target = CoarseSampleLocationNV;
31377    fn deref(&self) -> &Self::Target {
31378        &self.inner
31379    }
31380}
31381impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> {
31382    fn deref_mut(&mut self) -> &mut Self::Target {
31383        &mut self.inner
31384    }
31385}
31386impl<'a> CoarseSampleLocationNVBuilder<'a> {
31387    pub fn pixel_x(mut self, pixel_x: u32) -> Self {
31388        self.inner.pixel_x = pixel_x;
31389        self
31390    }
31391    pub fn pixel_y(mut self, pixel_y: u32) -> Self {
31392        self.inner.pixel_y = pixel_y;
31393        self
31394    }
31395    pub fn sample(mut self, sample: u32) -> Self {
31396        self.inner.sample = sample;
31397        self
31398    }
31399    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31400    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31401    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31402    pub fn build(self) -> CoarseSampleLocationNV {
31403        self.inner
31404    }
31405}
31406#[repr(C)]
31407#[cfg_attr(feature = "debug", derive(Debug))]
31408#[derive(Copy, Clone)]
31409#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleOrderCustomNV.html>"]
31410pub struct CoarseSampleOrderCustomNV {
31411    pub shading_rate: ShadingRatePaletteEntryNV,
31412    pub sample_count: u32,
31413    pub sample_location_count: u32,
31414    pub p_sample_locations: *const CoarseSampleLocationNV,
31415}
31416impl ::std::default::Default for CoarseSampleOrderCustomNV {
31417    fn default() -> Self {
31418        Self {
31419            shading_rate: ShadingRatePaletteEntryNV::default(),
31420            sample_count: u32::default(),
31421            sample_location_count: u32::default(),
31422            p_sample_locations: ::std::ptr::null(),
31423        }
31424    }
31425}
31426impl CoarseSampleOrderCustomNV {
31427    pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> {
31428        CoarseSampleOrderCustomNVBuilder {
31429            inner: Self::default(),
31430            marker: ::std::marker::PhantomData,
31431        }
31432    }
31433}
31434#[repr(transparent)]
31435pub struct CoarseSampleOrderCustomNVBuilder<'a> {
31436    inner: CoarseSampleOrderCustomNV,
31437    marker: ::std::marker::PhantomData<&'a ()>,
31438}
31439impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> {
31440    type Target = CoarseSampleOrderCustomNV;
31441    fn deref(&self) -> &Self::Target {
31442        &self.inner
31443    }
31444}
31445impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> {
31446    fn deref_mut(&mut self) -> &mut Self::Target {
31447        &mut self.inner
31448    }
31449}
31450impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
31451    pub fn shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self {
31452        self.inner.shading_rate = shading_rate;
31453        self
31454    }
31455    pub fn sample_count(mut self, sample_count: u32) -> Self {
31456        self.inner.sample_count = sample_count;
31457        self
31458    }
31459    pub fn sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self {
31460        self.inner.sample_location_count = sample_locations.len() as _;
31461        self.inner.p_sample_locations = sample_locations.as_ptr();
31462        self
31463    }
31464    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31465    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31466    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31467    pub fn build(self) -> CoarseSampleOrderCustomNV {
31468        self.inner
31469    }
31470}
31471#[repr(C)]
31472#[cfg_attr(feature = "debug", derive(Debug))]
31473#[derive(Copy, Clone)]
31474#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>"]
31475pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31476    pub s_type: StructureType,
31477    pub p_next: *const c_void,
31478    pub sample_order_type: CoarseSampleOrderTypeNV,
31479    pub custom_sample_order_count: u32,
31480    pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
31481}
31482impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31483    fn default() -> Self {
31484        Self {
31485            s_type: StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
31486            p_next: ::std::ptr::null(),
31487            sample_order_type: CoarseSampleOrderTypeNV::default(),
31488            custom_sample_order_count: u32::default(),
31489            p_custom_sample_orders: ::std::ptr::null(),
31490        }
31491    }
31492}
31493impl PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31494    pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31495        PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder {
31496            inner: Self::default(),
31497            marker: ::std::marker::PhantomData,
31498        }
31499    }
31500}
31501#[repr(transparent)]
31502pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31503    inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV,
31504    marker: ::std::marker::PhantomData<&'a ()>,
31505}
31506unsafe impl ExtendsPipelineViewportStateCreateInfo
31507    for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_>
31508{
31509}
31510unsafe impl ExtendsPipelineViewportStateCreateInfo
31511    for PipelineViewportCoarseSampleOrderStateCreateInfoNV
31512{
31513}
31514impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31515    type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
31516    fn deref(&self) -> &Self::Target {
31517        &self.inner
31518    }
31519}
31520impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31521    fn deref_mut(&mut self) -> &mut Self::Target {
31522        &mut self.inner
31523    }
31524}
31525impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
31526    pub fn sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self {
31527        self.inner.sample_order_type = sample_order_type;
31528        self
31529    }
31530    pub fn custom_sample_orders(
31531        mut self,
31532        custom_sample_orders: &'a [CoarseSampleOrderCustomNV],
31533    ) -> Self {
31534        self.inner.custom_sample_order_count = custom_sample_orders.len() as _;
31535        self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr();
31536        self
31537    }
31538    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31539    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31540    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31541    pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
31542        self.inner
31543    }
31544}
31545#[repr(C)]
31546#[cfg_attr(feature = "debug", derive(Debug))]
31547#[derive(Copy, Clone)]
31548#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>"]
31549pub struct PhysicalDeviceMeshShaderFeaturesNV {
31550    pub s_type: StructureType,
31551    pub p_next: *mut c_void,
31552    pub task_shader: Bool32,
31553    pub mesh_shader: Bool32,
31554}
31555impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV {
31556    fn default() -> Self {
31557        Self {
31558            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
31559            p_next: ::std::ptr::null_mut(),
31560            task_shader: Bool32::default(),
31561            mesh_shader: Bool32::default(),
31562        }
31563    }
31564}
31565impl PhysicalDeviceMeshShaderFeaturesNV {
31566    pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31567        PhysicalDeviceMeshShaderFeaturesNVBuilder {
31568            inner: Self::default(),
31569            marker: ::std::marker::PhantomData,
31570        }
31571    }
31572}
31573#[repr(transparent)]
31574pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31575    inner: PhysicalDeviceMeshShaderFeaturesNV,
31576    marker: ::std::marker::PhantomData<&'a ()>,
31577}
31578unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
31579unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {}
31580unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
31581unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {}
31582impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31583    type Target = PhysicalDeviceMeshShaderFeaturesNV;
31584    fn deref(&self) -> &Self::Target {
31585        &self.inner
31586    }
31587}
31588impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31589    fn deref_mut(&mut self) -> &mut Self::Target {
31590        &mut self.inner
31591    }
31592}
31593impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
31594    pub fn task_shader(mut self, task_shader: bool) -> Self {
31595        self.inner.task_shader = task_shader.into();
31596        self
31597    }
31598    pub fn mesh_shader(mut self, mesh_shader: bool) -> Self {
31599        self.inner.mesh_shader = mesh_shader.into();
31600        self
31601    }
31602    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31603    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31604    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31605    pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV {
31606        self.inner
31607    }
31608}
31609#[repr(C)]
31610#[cfg_attr(feature = "debug", derive(Debug))]
31611#[derive(Copy, Clone)]
31612#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>"]
31613pub struct PhysicalDeviceMeshShaderPropertiesNV {
31614    pub s_type: StructureType,
31615    pub p_next: *mut c_void,
31616    pub max_draw_mesh_tasks_count: u32,
31617    pub max_task_work_group_invocations: u32,
31618    pub max_task_work_group_size: [u32; 3],
31619    pub max_task_total_memory_size: u32,
31620    pub max_task_output_count: u32,
31621    pub max_mesh_work_group_invocations: u32,
31622    pub max_mesh_work_group_size: [u32; 3],
31623    pub max_mesh_total_memory_size: u32,
31624    pub max_mesh_output_vertices: u32,
31625    pub max_mesh_output_primitives: u32,
31626    pub max_mesh_multiview_view_count: u32,
31627    pub mesh_output_per_vertex_granularity: u32,
31628    pub mesh_output_per_primitive_granularity: u32,
31629}
31630impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV {
31631    fn default() -> Self {
31632        Self {
31633            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
31634            p_next: ::std::ptr::null_mut(),
31635            max_draw_mesh_tasks_count: u32::default(),
31636            max_task_work_group_invocations: u32::default(),
31637            max_task_work_group_size: unsafe { ::std::mem::zeroed() },
31638            max_task_total_memory_size: u32::default(),
31639            max_task_output_count: u32::default(),
31640            max_mesh_work_group_invocations: u32::default(),
31641            max_mesh_work_group_size: unsafe { ::std::mem::zeroed() },
31642            max_mesh_total_memory_size: u32::default(),
31643            max_mesh_output_vertices: u32::default(),
31644            max_mesh_output_primitives: u32::default(),
31645            max_mesh_multiview_view_count: u32::default(),
31646            mesh_output_per_vertex_granularity: u32::default(),
31647            mesh_output_per_primitive_granularity: u32::default(),
31648        }
31649    }
31650}
31651impl PhysicalDeviceMeshShaderPropertiesNV {
31652    pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31653        PhysicalDeviceMeshShaderPropertiesNVBuilder {
31654            inner: Self::default(),
31655            marker: ::std::marker::PhantomData,
31656        }
31657    }
31658}
31659#[repr(transparent)]
31660pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31661    inner: PhysicalDeviceMeshShaderPropertiesNV,
31662    marker: ::std::marker::PhantomData<&'a ()>,
31663}
31664unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {}
31665unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {}
31666impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31667    type Target = PhysicalDeviceMeshShaderPropertiesNV;
31668    fn deref(&self) -> &Self::Target {
31669        &self.inner
31670    }
31671}
31672impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31673    fn deref_mut(&mut self) -> &mut Self::Target {
31674        &mut self.inner
31675    }
31676}
31677impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
31678    pub fn max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self {
31679        self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count;
31680        self
31681    }
31682    pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self {
31683        self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
31684        self
31685    }
31686    pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self {
31687        self.inner.max_task_work_group_size = max_task_work_group_size;
31688        self
31689    }
31690    pub fn max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self {
31691        self.inner.max_task_total_memory_size = max_task_total_memory_size;
31692        self
31693    }
31694    pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self {
31695        self.inner.max_task_output_count = max_task_output_count;
31696        self
31697    }
31698    pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self {
31699        self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
31700        self
31701    }
31702    pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self {
31703        self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
31704        self
31705    }
31706    pub fn max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self {
31707        self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size;
31708        self
31709    }
31710    pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self {
31711        self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
31712        self
31713    }
31714    pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self {
31715        self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
31716        self
31717    }
31718    pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self {
31719        self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
31720        self
31721    }
31722    pub fn mesh_output_per_vertex_granularity(
31723        mut self,
31724        mesh_output_per_vertex_granularity: u32,
31725    ) -> Self {
31726        self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
31727        self
31728    }
31729    pub fn mesh_output_per_primitive_granularity(
31730        mut self,
31731        mesh_output_per_primitive_granularity: u32,
31732    ) -> Self {
31733        self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity;
31734        self
31735    }
31736    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31737    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31738    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31739    pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV {
31740        self.inner
31741    }
31742}
31743#[repr(C)]
31744#[cfg_attr(feature = "debug", derive(Debug))]
31745#[derive(Copy, Clone, Default)]
31746#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html>"]
31747pub struct DrawMeshTasksIndirectCommandNV {
31748    pub task_count: u32,
31749    pub first_task: u32,
31750}
31751impl DrawMeshTasksIndirectCommandNV {
31752    pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
31753        DrawMeshTasksIndirectCommandNVBuilder {
31754            inner: Self::default(),
31755            marker: ::std::marker::PhantomData,
31756        }
31757    }
31758}
31759#[repr(transparent)]
31760pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> {
31761    inner: DrawMeshTasksIndirectCommandNV,
31762    marker: ::std::marker::PhantomData<&'a ()>,
31763}
31764impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> {
31765    type Target = DrawMeshTasksIndirectCommandNV;
31766    fn deref(&self) -> &Self::Target {
31767        &self.inner
31768    }
31769}
31770impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> {
31771    fn deref_mut(&mut self) -> &mut Self::Target {
31772        &mut self.inner
31773    }
31774}
31775impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> {
31776    pub fn task_count(mut self, task_count: u32) -> Self {
31777        self.inner.task_count = task_count;
31778        self
31779    }
31780    pub fn first_task(mut self, first_task: u32) -> Self {
31781        self.inner.first_task = first_task;
31782        self
31783    }
31784    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31785    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31786    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31787    pub fn build(self) -> DrawMeshTasksIndirectCommandNV {
31788        self.inner
31789    }
31790}
31791#[repr(C)]
31792#[cfg_attr(feature = "debug", derive(Debug))]
31793#[derive(Copy, Clone)]
31794#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html>"]
31795pub struct RayTracingShaderGroupCreateInfoNV {
31796    pub s_type: StructureType,
31797    pub p_next: *const c_void,
31798    pub ty: RayTracingShaderGroupTypeKHR,
31799    pub general_shader: u32,
31800    pub closest_hit_shader: u32,
31801    pub any_hit_shader: u32,
31802    pub intersection_shader: u32,
31803}
31804impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV {
31805    fn default() -> Self {
31806        Self {
31807            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
31808            p_next: ::std::ptr::null(),
31809            ty: RayTracingShaderGroupTypeKHR::default(),
31810            general_shader: u32::default(),
31811            closest_hit_shader: u32::default(),
31812            any_hit_shader: u32::default(),
31813            intersection_shader: u32::default(),
31814        }
31815    }
31816}
31817impl RayTracingShaderGroupCreateInfoNV {
31818    pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31819        RayTracingShaderGroupCreateInfoNVBuilder {
31820            inner: Self::default(),
31821            marker: ::std::marker::PhantomData,
31822        }
31823    }
31824}
31825#[repr(transparent)]
31826pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31827    inner: RayTracingShaderGroupCreateInfoNV,
31828    marker: ::std::marker::PhantomData<&'a ()>,
31829}
31830impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31831    type Target = RayTracingShaderGroupCreateInfoNV;
31832    fn deref(&self) -> &Self::Target {
31833        &self.inner
31834    }
31835}
31836impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31837    fn deref_mut(&mut self) -> &mut Self::Target {
31838        &mut self.inner
31839    }
31840}
31841impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
31842    pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
31843        self.inner.ty = ty;
31844        self
31845    }
31846    pub fn general_shader(mut self, general_shader: u32) -> Self {
31847        self.inner.general_shader = general_shader;
31848        self
31849    }
31850    pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
31851        self.inner.closest_hit_shader = closest_hit_shader;
31852        self
31853    }
31854    pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
31855        self.inner.any_hit_shader = any_hit_shader;
31856        self
31857    }
31858    pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
31859        self.inner.intersection_shader = intersection_shader;
31860        self
31861    }
31862    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31863    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31864    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31865    pub fn build(self) -> RayTracingShaderGroupCreateInfoNV {
31866        self.inner
31867    }
31868}
31869#[repr(C)]
31870#[cfg_attr(feature = "debug", derive(Debug))]
31871#[derive(Copy, Clone)]
31872#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>"]
31873pub struct RayTracingShaderGroupCreateInfoKHR {
31874    pub s_type: StructureType,
31875    pub p_next: *const c_void,
31876    pub ty: RayTracingShaderGroupTypeKHR,
31877    pub general_shader: u32,
31878    pub closest_hit_shader: u32,
31879    pub any_hit_shader: u32,
31880    pub intersection_shader: u32,
31881    pub p_shader_group_capture_replay_handle: *const c_void,
31882}
31883impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR {
31884    fn default() -> Self {
31885        Self {
31886            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
31887            p_next: ::std::ptr::null(),
31888            ty: RayTracingShaderGroupTypeKHR::default(),
31889            general_shader: u32::default(),
31890            closest_hit_shader: u32::default(),
31891            any_hit_shader: u32::default(),
31892            intersection_shader: u32::default(),
31893            p_shader_group_capture_replay_handle: ::std::ptr::null(),
31894        }
31895    }
31896}
31897impl RayTracingShaderGroupCreateInfoKHR {
31898    pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31899        RayTracingShaderGroupCreateInfoKHRBuilder {
31900            inner: Self::default(),
31901            marker: ::std::marker::PhantomData,
31902        }
31903    }
31904}
31905#[repr(transparent)]
31906pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31907    inner: RayTracingShaderGroupCreateInfoKHR,
31908    marker: ::std::marker::PhantomData<&'a ()>,
31909}
31910impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31911    type Target = RayTracingShaderGroupCreateInfoKHR;
31912    fn deref(&self) -> &Self::Target {
31913        &self.inner
31914    }
31915}
31916impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31917    fn deref_mut(&mut self) -> &mut Self::Target {
31918        &mut self.inner
31919    }
31920}
31921impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
31922    pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
31923        self.inner.ty = ty;
31924        self
31925    }
31926    pub fn general_shader(mut self, general_shader: u32) -> Self {
31927        self.inner.general_shader = general_shader;
31928        self
31929    }
31930    pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
31931        self.inner.closest_hit_shader = closest_hit_shader;
31932        self
31933    }
31934    pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
31935        self.inner.any_hit_shader = any_hit_shader;
31936        self
31937    }
31938    pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
31939        self.inner.intersection_shader = intersection_shader;
31940        self
31941    }
31942    pub fn shader_group_capture_replay_handle(
31943        mut self,
31944        shader_group_capture_replay_handle: *const c_void,
31945    ) -> Self {
31946        self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle;
31947        self
31948    }
31949    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31950    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31951    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
31952    pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR {
31953        self.inner
31954    }
31955}
31956#[repr(C)]
31957#[cfg_attr(feature = "debug", derive(Debug))]
31958#[derive(Copy, Clone)]
31959#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html>"]
31960pub struct RayTracingPipelineCreateInfoNV {
31961    pub s_type: StructureType,
31962    pub p_next: *const c_void,
31963    pub flags: PipelineCreateFlags,
31964    pub stage_count: u32,
31965    pub p_stages: *const PipelineShaderStageCreateInfo,
31966    pub group_count: u32,
31967    pub p_groups: *const RayTracingShaderGroupCreateInfoNV,
31968    pub max_recursion_depth: u32,
31969    pub layout: PipelineLayout,
31970    pub base_pipeline_handle: Pipeline,
31971    pub base_pipeline_index: i32,
31972}
31973impl ::std::default::Default for RayTracingPipelineCreateInfoNV {
31974    fn default() -> Self {
31975        Self {
31976            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV,
31977            p_next: ::std::ptr::null(),
31978            flags: PipelineCreateFlags::default(),
31979            stage_count: u32::default(),
31980            p_stages: ::std::ptr::null(),
31981            group_count: u32::default(),
31982            p_groups: ::std::ptr::null(),
31983            max_recursion_depth: u32::default(),
31984            layout: PipelineLayout::default(),
31985            base_pipeline_handle: Pipeline::default(),
31986            base_pipeline_index: i32::default(),
31987        }
31988    }
31989}
31990impl RayTracingPipelineCreateInfoNV {
31991    pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> {
31992        RayTracingPipelineCreateInfoNVBuilder {
31993            inner: Self::default(),
31994            marker: ::std::marker::PhantomData,
31995        }
31996    }
31997}
31998#[repr(transparent)]
31999pub struct RayTracingPipelineCreateInfoNVBuilder<'a> {
32000    inner: RayTracingPipelineCreateInfoNV,
32001    marker: ::std::marker::PhantomData<&'a ()>,
32002}
32003pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {}
32004impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> {
32005    type Target = RayTracingPipelineCreateInfoNV;
32006    fn deref(&self) -> &Self::Target {
32007        &self.inner
32008    }
32009}
32010impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> {
32011    fn deref_mut(&mut self) -> &mut Self::Target {
32012        &mut self.inner
32013    }
32014}
32015impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
32016    pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
32017        self.inner.flags = flags;
32018        self
32019    }
32020    pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
32021        self.inner.stage_count = stages.len() as _;
32022        self.inner.p_stages = stages.as_ptr();
32023        self
32024    }
32025    pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self {
32026        self.inner.group_count = groups.len() as _;
32027        self.inner.p_groups = groups.as_ptr();
32028        self
32029    }
32030    pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
32031        self.inner.max_recursion_depth = max_recursion_depth;
32032        self
32033    }
32034    pub fn layout(mut self, layout: PipelineLayout) -> Self {
32035        self.inner.layout = layout;
32036        self
32037    }
32038    pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
32039        self.inner.base_pipeline_handle = base_pipeline_handle;
32040        self
32041    }
32042    pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
32043        self.inner.base_pipeline_index = base_pipeline_index;
32044        self
32045    }
32046    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
32047    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
32048    #[doc = r" valid extension structs can be pushed into the chain."]
32049    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
32050    #[doc = r" chain will look like `A -> D -> B -> C`."]
32051    pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(mut self, next: &'a mut T) -> Self {
32052        unsafe {
32053            let next_ptr = <*const T>::cast(next);
32054            let last_next = ptr_chain_iter(next).last().unwrap();
32055            (*last_next).p_next = self.inner.p_next as _;
32056            self.inner.p_next = next_ptr;
32057        }
32058        self
32059    }
32060    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32061    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32062    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32063    pub fn build(self) -> RayTracingPipelineCreateInfoNV {
32064        self.inner
32065    }
32066}
32067#[repr(C)]
32068#[cfg_attr(feature = "debug", derive(Debug))]
32069#[derive(Copy, Clone)]
32070#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html>"]
32071pub struct RayTracingPipelineCreateInfoKHR {
32072    pub s_type: StructureType,
32073    pub p_next: *const c_void,
32074    pub flags: PipelineCreateFlags,
32075    pub stage_count: u32,
32076    pub p_stages: *const PipelineShaderStageCreateInfo,
32077    pub group_count: u32,
32078    pub p_groups: *const RayTracingShaderGroupCreateInfoKHR,
32079    pub max_pipeline_ray_recursion_depth: u32,
32080    pub p_library_info: *const PipelineLibraryCreateInfoKHR,
32081    pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR,
32082    pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
32083    pub layout: PipelineLayout,
32084    pub base_pipeline_handle: Pipeline,
32085    pub base_pipeline_index: i32,
32086}
32087impl ::std::default::Default for RayTracingPipelineCreateInfoKHR {
32088    fn default() -> Self {
32089        Self {
32090            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
32091            p_next: ::std::ptr::null(),
32092            flags: PipelineCreateFlags::default(),
32093            stage_count: u32::default(),
32094            p_stages: ::std::ptr::null(),
32095            group_count: u32::default(),
32096            p_groups: ::std::ptr::null(),
32097            max_pipeline_ray_recursion_depth: u32::default(),
32098            p_library_info: ::std::ptr::null(),
32099            p_library_interface: ::std::ptr::null(),
32100            p_dynamic_state: ::std::ptr::null(),
32101            layout: PipelineLayout::default(),
32102            base_pipeline_handle: Pipeline::default(),
32103            base_pipeline_index: i32::default(),
32104        }
32105    }
32106}
32107impl RayTracingPipelineCreateInfoKHR {
32108    pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
32109        RayTracingPipelineCreateInfoKHRBuilder {
32110            inner: Self::default(),
32111            marker: ::std::marker::PhantomData,
32112        }
32113    }
32114}
32115#[repr(transparent)]
32116pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> {
32117    inner: RayTracingPipelineCreateInfoKHR,
32118    marker: ::std::marker::PhantomData<&'a ()>,
32119}
32120pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {}
32121impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> {
32122    type Target = RayTracingPipelineCreateInfoKHR;
32123    fn deref(&self) -> &Self::Target {
32124        &self.inner
32125    }
32126}
32127impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> {
32128    fn deref_mut(&mut self) -> &mut Self::Target {
32129        &mut self.inner
32130    }
32131}
32132impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
32133    pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
32134        self.inner.flags = flags;
32135        self
32136    }
32137    pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
32138        self.inner.stage_count = stages.len() as _;
32139        self.inner.p_stages = stages.as_ptr();
32140        self
32141    }
32142    pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self {
32143        self.inner.group_count = groups.len() as _;
32144        self.inner.p_groups = groups.as_ptr();
32145        self
32146    }
32147    pub fn max_pipeline_ray_recursion_depth(
32148        mut self,
32149        max_pipeline_ray_recursion_depth: u32,
32150    ) -> Self {
32151        self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth;
32152        self
32153    }
32154    pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self {
32155        self.inner.p_library_info = library_info;
32156        self
32157    }
32158    pub fn library_interface(
32159        mut self,
32160        library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR,
32161    ) -> Self {
32162        self.inner.p_library_interface = library_interface;
32163        self
32164    }
32165    pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
32166        self.inner.p_dynamic_state = dynamic_state;
32167        self
32168    }
32169    pub fn layout(mut self, layout: PipelineLayout) -> Self {
32170        self.inner.layout = layout;
32171        self
32172    }
32173    pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
32174        self.inner.base_pipeline_handle = base_pipeline_handle;
32175        self
32176    }
32177    pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
32178        self.inner.base_pipeline_index = base_pipeline_index;
32179        self
32180    }
32181    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
32182    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
32183    #[doc = r" valid extension structs can be pushed into the chain."]
32184    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
32185    #[doc = r" chain will look like `A -> D -> B -> C`."]
32186    pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
32187        unsafe {
32188            let next_ptr = <*const T>::cast(next);
32189            let last_next = ptr_chain_iter(next).last().unwrap();
32190            (*last_next).p_next = self.inner.p_next as _;
32191            self.inner.p_next = next_ptr;
32192        }
32193        self
32194    }
32195    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32196    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32197    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32198    pub fn build(self) -> RayTracingPipelineCreateInfoKHR {
32199        self.inner
32200    }
32201}
32202#[repr(C)]
32203#[cfg_attr(feature = "debug", derive(Debug))]
32204#[derive(Copy, Clone)]
32205#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryTrianglesNV.html>"]
32206pub struct GeometryTrianglesNV {
32207    pub s_type: StructureType,
32208    pub p_next: *const c_void,
32209    pub vertex_data: Buffer,
32210    pub vertex_offset: DeviceSize,
32211    pub vertex_count: u32,
32212    pub vertex_stride: DeviceSize,
32213    pub vertex_format: Format,
32214    pub index_data: Buffer,
32215    pub index_offset: DeviceSize,
32216    pub index_count: u32,
32217    pub index_type: IndexType,
32218    pub transform_data: Buffer,
32219    pub transform_offset: DeviceSize,
32220}
32221impl ::std::default::Default for GeometryTrianglesNV {
32222    fn default() -> Self {
32223        Self {
32224            s_type: StructureType::GEOMETRY_TRIANGLES_NV,
32225            p_next: ::std::ptr::null(),
32226            vertex_data: Buffer::default(),
32227            vertex_offset: DeviceSize::default(),
32228            vertex_count: u32::default(),
32229            vertex_stride: DeviceSize::default(),
32230            vertex_format: Format::default(),
32231            index_data: Buffer::default(),
32232            index_offset: DeviceSize::default(),
32233            index_count: u32::default(),
32234            index_type: IndexType::default(),
32235            transform_data: Buffer::default(),
32236            transform_offset: DeviceSize::default(),
32237        }
32238    }
32239}
32240impl GeometryTrianglesNV {
32241    pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> {
32242        GeometryTrianglesNVBuilder {
32243            inner: Self::default(),
32244            marker: ::std::marker::PhantomData,
32245        }
32246    }
32247}
32248#[repr(transparent)]
32249pub struct GeometryTrianglesNVBuilder<'a> {
32250    inner: GeometryTrianglesNV,
32251    marker: ::std::marker::PhantomData<&'a ()>,
32252}
32253impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> {
32254    type Target = GeometryTrianglesNV;
32255    fn deref(&self) -> &Self::Target {
32256        &self.inner
32257    }
32258}
32259impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> {
32260    fn deref_mut(&mut self) -> &mut Self::Target {
32261        &mut self.inner
32262    }
32263}
32264impl<'a> GeometryTrianglesNVBuilder<'a> {
32265    pub fn vertex_data(mut self, vertex_data: Buffer) -> Self {
32266        self.inner.vertex_data = vertex_data;
32267        self
32268    }
32269    pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> Self {
32270        self.inner.vertex_offset = vertex_offset;
32271        self
32272    }
32273    pub fn vertex_count(mut self, vertex_count: u32) -> Self {
32274        self.inner.vertex_count = vertex_count;
32275        self
32276    }
32277    pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
32278        self.inner.vertex_stride = vertex_stride;
32279        self
32280    }
32281    pub fn vertex_format(mut self, vertex_format: Format) -> Self {
32282        self.inner.vertex_format = vertex_format;
32283        self
32284    }
32285    pub fn index_data(mut self, index_data: Buffer) -> Self {
32286        self.inner.index_data = index_data;
32287        self
32288    }
32289    pub fn index_offset(mut self, index_offset: DeviceSize) -> Self {
32290        self.inner.index_offset = index_offset;
32291        self
32292    }
32293    pub fn index_count(mut self, index_count: u32) -> Self {
32294        self.inner.index_count = index_count;
32295        self
32296    }
32297    pub fn index_type(mut self, index_type: IndexType) -> Self {
32298        self.inner.index_type = index_type;
32299        self
32300    }
32301    pub fn transform_data(mut self, transform_data: Buffer) -> Self {
32302        self.inner.transform_data = transform_data;
32303        self
32304    }
32305    pub fn transform_offset(mut self, transform_offset: DeviceSize) -> Self {
32306        self.inner.transform_offset = transform_offset;
32307        self
32308    }
32309    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32310    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32311    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32312    pub fn build(self) -> GeometryTrianglesNV {
32313        self.inner
32314    }
32315}
32316#[repr(C)]
32317#[cfg_attr(feature = "debug", derive(Debug))]
32318#[derive(Copy, Clone)]
32319#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryAABBNV.html>"]
32320pub struct GeometryAABBNV {
32321    pub s_type: StructureType,
32322    pub p_next: *const c_void,
32323    pub aabb_data: Buffer,
32324    pub num_aab_bs: u32,
32325    pub stride: u32,
32326    pub offset: DeviceSize,
32327}
32328impl ::std::default::Default for GeometryAABBNV {
32329    fn default() -> Self {
32330        Self {
32331            s_type: StructureType::GEOMETRY_AABB_NV,
32332            p_next: ::std::ptr::null(),
32333            aabb_data: Buffer::default(),
32334            num_aab_bs: u32::default(),
32335            stride: u32::default(),
32336            offset: DeviceSize::default(),
32337        }
32338    }
32339}
32340impl GeometryAABBNV {
32341    pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> {
32342        GeometryAABBNVBuilder {
32343            inner: Self::default(),
32344            marker: ::std::marker::PhantomData,
32345        }
32346    }
32347}
32348#[repr(transparent)]
32349pub struct GeometryAABBNVBuilder<'a> {
32350    inner: GeometryAABBNV,
32351    marker: ::std::marker::PhantomData<&'a ()>,
32352}
32353impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> {
32354    type Target = GeometryAABBNV;
32355    fn deref(&self) -> &Self::Target {
32356        &self.inner
32357    }
32358}
32359impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> {
32360    fn deref_mut(&mut self) -> &mut Self::Target {
32361        &mut self.inner
32362    }
32363}
32364impl<'a> GeometryAABBNVBuilder<'a> {
32365    pub fn aabb_data(mut self, aabb_data: Buffer) -> Self {
32366        self.inner.aabb_data = aabb_data;
32367        self
32368    }
32369    pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self {
32370        self.inner.num_aab_bs = num_aab_bs;
32371        self
32372    }
32373    pub fn stride(mut self, stride: u32) -> Self {
32374        self.inner.stride = stride;
32375        self
32376    }
32377    pub fn offset(mut self, offset: DeviceSize) -> Self {
32378        self.inner.offset = offset;
32379        self
32380    }
32381    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32382    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32383    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32384    pub fn build(self) -> GeometryAABBNV {
32385        self.inner
32386    }
32387}
32388#[repr(C)]
32389#[cfg_attr(feature = "debug", derive(Debug))]
32390#[derive(Copy, Clone, Default)]
32391#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryDataNV.html>"]
32392pub struct GeometryDataNV {
32393    pub triangles: GeometryTrianglesNV,
32394    pub aabbs: GeometryAABBNV,
32395}
32396impl GeometryDataNV {
32397    pub fn builder<'a>() -> GeometryDataNVBuilder<'a> {
32398        GeometryDataNVBuilder {
32399            inner: Self::default(),
32400            marker: ::std::marker::PhantomData,
32401        }
32402    }
32403}
32404#[repr(transparent)]
32405pub struct GeometryDataNVBuilder<'a> {
32406    inner: GeometryDataNV,
32407    marker: ::std::marker::PhantomData<&'a ()>,
32408}
32409impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> {
32410    type Target = GeometryDataNV;
32411    fn deref(&self) -> &Self::Target {
32412        &self.inner
32413    }
32414}
32415impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> {
32416    fn deref_mut(&mut self) -> &mut Self::Target {
32417        &mut self.inner
32418    }
32419}
32420impl<'a> GeometryDataNVBuilder<'a> {
32421    pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> Self {
32422        self.inner.triangles = triangles;
32423        self
32424    }
32425    pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> Self {
32426        self.inner.aabbs = aabbs;
32427        self
32428    }
32429    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32430    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32431    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32432    pub fn build(self) -> GeometryDataNV {
32433        self.inner
32434    }
32435}
32436#[repr(C)]
32437#[cfg_attr(feature = "debug", derive(Debug))]
32438#[derive(Copy, Clone)]
32439#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryNV.html>"]
32440pub struct GeometryNV {
32441    pub s_type: StructureType,
32442    pub p_next: *const c_void,
32443    pub geometry_type: GeometryTypeKHR,
32444    pub geometry: GeometryDataNV,
32445    pub flags: GeometryFlagsKHR,
32446}
32447impl ::std::default::Default for GeometryNV {
32448    fn default() -> Self {
32449        Self {
32450            s_type: StructureType::GEOMETRY_NV,
32451            p_next: ::std::ptr::null(),
32452            geometry_type: GeometryTypeKHR::default(),
32453            geometry: GeometryDataNV::default(),
32454            flags: GeometryFlagsKHR::default(),
32455        }
32456    }
32457}
32458impl GeometryNV {
32459    pub fn builder<'a>() -> GeometryNVBuilder<'a> {
32460        GeometryNVBuilder {
32461            inner: Self::default(),
32462            marker: ::std::marker::PhantomData,
32463        }
32464    }
32465}
32466#[repr(transparent)]
32467pub struct GeometryNVBuilder<'a> {
32468    inner: GeometryNV,
32469    marker: ::std::marker::PhantomData<&'a ()>,
32470}
32471impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> {
32472    type Target = GeometryNV;
32473    fn deref(&self) -> &Self::Target {
32474        &self.inner
32475    }
32476}
32477impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> {
32478    fn deref_mut(&mut self) -> &mut Self::Target {
32479        &mut self.inner
32480    }
32481}
32482impl<'a> GeometryNVBuilder<'a> {
32483    pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
32484        self.inner.geometry_type = geometry_type;
32485        self
32486    }
32487    pub fn geometry(mut self, geometry: GeometryDataNV) -> Self {
32488        self.inner.geometry = geometry;
32489        self
32490    }
32491    pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
32492        self.inner.flags = flags;
32493        self
32494    }
32495    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32496    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32497    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32498    pub fn build(self) -> GeometryNV {
32499        self.inner
32500    }
32501}
32502#[repr(C)]
32503#[cfg_attr(feature = "debug", derive(Debug))]
32504#[derive(Copy, Clone)]
32505#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInfoNV.html>"]
32506pub struct AccelerationStructureInfoNV {
32507    pub s_type: StructureType,
32508    pub p_next: *const c_void,
32509    pub ty: AccelerationStructureTypeNV,
32510    pub flags: BuildAccelerationStructureFlagsNV,
32511    pub instance_count: u32,
32512    pub geometry_count: u32,
32513    pub p_geometries: *const GeometryNV,
32514}
32515impl ::std::default::Default for AccelerationStructureInfoNV {
32516    fn default() -> Self {
32517        Self {
32518            s_type: StructureType::ACCELERATION_STRUCTURE_INFO_NV,
32519            p_next: ::std::ptr::null(),
32520            ty: AccelerationStructureTypeNV::default(),
32521            flags: BuildAccelerationStructureFlagsNV::default(),
32522            instance_count: u32::default(),
32523            geometry_count: u32::default(),
32524            p_geometries: ::std::ptr::null(),
32525        }
32526    }
32527}
32528impl AccelerationStructureInfoNV {
32529    pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> {
32530        AccelerationStructureInfoNVBuilder {
32531            inner: Self::default(),
32532            marker: ::std::marker::PhantomData,
32533        }
32534    }
32535}
32536#[repr(transparent)]
32537pub struct AccelerationStructureInfoNVBuilder<'a> {
32538    inner: AccelerationStructureInfoNV,
32539    marker: ::std::marker::PhantomData<&'a ()>,
32540}
32541impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> {
32542    type Target = AccelerationStructureInfoNV;
32543    fn deref(&self) -> &Self::Target {
32544        &self.inner
32545    }
32546}
32547impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> {
32548    fn deref_mut(&mut self) -> &mut Self::Target {
32549        &mut self.inner
32550    }
32551}
32552impl<'a> AccelerationStructureInfoNVBuilder<'a> {
32553    pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> Self {
32554        self.inner.ty = ty;
32555        self
32556    }
32557    pub fn flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self {
32558        self.inner.flags = flags;
32559        self
32560    }
32561    pub fn instance_count(mut self, instance_count: u32) -> Self {
32562        self.inner.instance_count = instance_count;
32563        self
32564    }
32565    pub fn geometries(mut self, geometries: &'a [GeometryNV]) -> Self {
32566        self.inner.geometry_count = geometries.len() as _;
32567        self.inner.p_geometries = geometries.as_ptr();
32568        self
32569    }
32570    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32571    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32572    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32573    pub fn build(self) -> AccelerationStructureInfoNV {
32574        self.inner
32575    }
32576}
32577#[repr(C)]
32578#[cfg_attr(feature = "debug", derive(Debug))]
32579#[derive(Copy, Clone)]
32580#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoNV.html>"]
32581pub struct AccelerationStructureCreateInfoNV {
32582    pub s_type: StructureType,
32583    pub p_next: *const c_void,
32584    pub compacted_size: DeviceSize,
32585    pub info: AccelerationStructureInfoNV,
32586}
32587impl ::std::default::Default for AccelerationStructureCreateInfoNV {
32588    fn default() -> Self {
32589        Self {
32590            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV,
32591            p_next: ::std::ptr::null(),
32592            compacted_size: DeviceSize::default(),
32593            info: AccelerationStructureInfoNV::default(),
32594        }
32595    }
32596}
32597impl AccelerationStructureCreateInfoNV {
32598    pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> {
32599        AccelerationStructureCreateInfoNVBuilder {
32600            inner: Self::default(),
32601            marker: ::std::marker::PhantomData,
32602        }
32603    }
32604}
32605#[repr(transparent)]
32606pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
32607    inner: AccelerationStructureCreateInfoNV,
32608    marker: ::std::marker::PhantomData<&'a ()>,
32609}
32610impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
32611    type Target = AccelerationStructureCreateInfoNV;
32612    fn deref(&self) -> &Self::Target {
32613        &self.inner
32614    }
32615}
32616impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> {
32617    fn deref_mut(&mut self) -> &mut Self::Target {
32618        &mut self.inner
32619    }
32620}
32621impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
32622    pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self {
32623        self.inner.compacted_size = compacted_size;
32624        self
32625    }
32626    pub fn info(mut self, info: AccelerationStructureInfoNV) -> Self {
32627        self.inner.info = info;
32628        self
32629    }
32630    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32631    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32632    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32633    pub fn build(self) -> AccelerationStructureCreateInfoNV {
32634        self.inner
32635    }
32636}
32637#[repr(C)]
32638#[cfg_attr(feature = "debug", derive(Debug))]
32639#[derive(Copy, Clone)]
32640#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindAccelerationStructureMemoryInfoNV.html>"]
32641pub struct BindAccelerationStructureMemoryInfoNV {
32642    pub s_type: StructureType,
32643    pub p_next: *const c_void,
32644    pub acceleration_structure: AccelerationStructureNV,
32645    pub memory: DeviceMemory,
32646    pub memory_offset: DeviceSize,
32647    pub device_index_count: u32,
32648    pub p_device_indices: *const u32,
32649}
32650impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV {
32651    fn default() -> Self {
32652        Self {
32653            s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
32654            p_next: ::std::ptr::null(),
32655            acceleration_structure: AccelerationStructureNV::default(),
32656            memory: DeviceMemory::default(),
32657            memory_offset: DeviceSize::default(),
32658            device_index_count: u32::default(),
32659            p_device_indices: ::std::ptr::null(),
32660        }
32661    }
32662}
32663impl BindAccelerationStructureMemoryInfoNV {
32664    pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32665        BindAccelerationStructureMemoryInfoNVBuilder {
32666            inner: Self::default(),
32667            marker: ::std::marker::PhantomData,
32668        }
32669    }
32670}
32671#[repr(transparent)]
32672pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32673    inner: BindAccelerationStructureMemoryInfoNV,
32674    marker: ::std::marker::PhantomData<&'a ()>,
32675}
32676impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32677    type Target = BindAccelerationStructureMemoryInfoNV;
32678    fn deref(&self) -> &Self::Target {
32679        &self.inner
32680    }
32681}
32682impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32683    fn deref_mut(&mut self) -> &mut Self::Target {
32684        &mut self.inner
32685    }
32686}
32687impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
32688    pub fn acceleration_structure(
32689        mut self,
32690        acceleration_structure: AccelerationStructureNV,
32691    ) -> Self {
32692        self.inner.acceleration_structure = acceleration_structure;
32693        self
32694    }
32695    pub fn memory(mut self, memory: DeviceMemory) -> Self {
32696        self.inner.memory = memory;
32697        self
32698    }
32699    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
32700        self.inner.memory_offset = memory_offset;
32701        self
32702    }
32703    pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
32704        self.inner.device_index_count = device_indices.len() as _;
32705        self.inner.p_device_indices = device_indices.as_ptr();
32706        self
32707    }
32708    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32709    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32710    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32711    pub fn build(self) -> BindAccelerationStructureMemoryInfoNV {
32712        self.inner
32713    }
32714}
32715#[repr(C)]
32716#[cfg_attr(feature = "debug", derive(Debug))]
32717#[derive(Copy, Clone)]
32718#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>"]
32719pub struct WriteDescriptorSetAccelerationStructureKHR {
32720    pub s_type: StructureType,
32721    pub p_next: *const c_void,
32722    pub acceleration_structure_count: u32,
32723    pub p_acceleration_structures: *const AccelerationStructureKHR,
32724}
32725impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR {
32726    fn default() -> Self {
32727        Self {
32728            s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
32729            p_next: ::std::ptr::null(),
32730            acceleration_structure_count: u32::default(),
32731            p_acceleration_structures: ::std::ptr::null(),
32732        }
32733    }
32734}
32735impl WriteDescriptorSetAccelerationStructureKHR {
32736    pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32737        WriteDescriptorSetAccelerationStructureKHRBuilder {
32738            inner: Self::default(),
32739            marker: ::std::marker::PhantomData,
32740        }
32741    }
32742}
32743#[repr(transparent)]
32744pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32745    inner: WriteDescriptorSetAccelerationStructureKHR,
32746    marker: ::std::marker::PhantomData<&'a ()>,
32747}
32748unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {}
32749unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {}
32750impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32751    type Target = WriteDescriptorSetAccelerationStructureKHR;
32752    fn deref(&self) -> &Self::Target {
32753        &self.inner
32754    }
32755}
32756impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32757    fn deref_mut(&mut self) -> &mut Self::Target {
32758        &mut self.inner
32759    }
32760}
32761impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
32762    pub fn acceleration_structures(
32763        mut self,
32764        acceleration_structures: &'a [AccelerationStructureKHR],
32765    ) -> Self {
32766        self.inner.acceleration_structure_count = acceleration_structures.len() as _;
32767        self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
32768        self
32769    }
32770    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32771    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32772    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32773    pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR {
32774        self.inner
32775    }
32776}
32777#[repr(C)]
32778#[cfg_attr(feature = "debug", derive(Debug))]
32779#[derive(Copy, Clone)]
32780#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureNV.html>"]
32781pub struct WriteDescriptorSetAccelerationStructureNV {
32782    pub s_type: StructureType,
32783    pub p_next: *const c_void,
32784    pub acceleration_structure_count: u32,
32785    pub p_acceleration_structures: *const AccelerationStructureNV,
32786}
32787impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV {
32788    fn default() -> Self {
32789        Self {
32790            s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
32791            p_next: ::std::ptr::null(),
32792            acceleration_structure_count: u32::default(),
32793            p_acceleration_structures: ::std::ptr::null(),
32794        }
32795    }
32796}
32797impl WriteDescriptorSetAccelerationStructureNV {
32798    pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32799        WriteDescriptorSetAccelerationStructureNVBuilder {
32800            inner: Self::default(),
32801            marker: ::std::marker::PhantomData,
32802        }
32803    }
32804}
32805#[repr(transparent)]
32806pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32807    inner: WriteDescriptorSetAccelerationStructureNV,
32808    marker: ::std::marker::PhantomData<&'a ()>,
32809}
32810unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {}
32811unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {}
32812impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32813    type Target = WriteDescriptorSetAccelerationStructureNV;
32814    fn deref(&self) -> &Self::Target {
32815        &self.inner
32816    }
32817}
32818impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32819    fn deref_mut(&mut self) -> &mut Self::Target {
32820        &mut self.inner
32821    }
32822}
32823impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
32824    pub fn acceleration_structures(
32825        mut self,
32826        acceleration_structures: &'a [AccelerationStructureNV],
32827    ) -> Self {
32828        self.inner.acceleration_structure_count = acceleration_structures.len() as _;
32829        self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
32830        self
32831    }
32832    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32833    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32834    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32835    pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV {
32836        self.inner
32837    }
32838}
32839#[repr(C)]
32840#[cfg_attr(feature = "debug", derive(Debug))]
32841#[derive(Copy, Clone)]
32842#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>"]
32843pub struct AccelerationStructureMemoryRequirementsInfoNV {
32844    pub s_type: StructureType,
32845    pub p_next: *const c_void,
32846    pub ty: AccelerationStructureMemoryRequirementsTypeNV,
32847    pub acceleration_structure: AccelerationStructureNV,
32848}
32849impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV {
32850    fn default() -> Self {
32851        Self {
32852            s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
32853            p_next: ::std::ptr::null(),
32854            ty: AccelerationStructureMemoryRequirementsTypeNV::default(),
32855            acceleration_structure: AccelerationStructureNV::default(),
32856        }
32857    }
32858}
32859impl AccelerationStructureMemoryRequirementsInfoNV {
32860    pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32861        AccelerationStructureMemoryRequirementsInfoNVBuilder {
32862            inner: Self::default(),
32863            marker: ::std::marker::PhantomData,
32864        }
32865    }
32866}
32867#[repr(transparent)]
32868pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32869    inner: AccelerationStructureMemoryRequirementsInfoNV,
32870    marker: ::std::marker::PhantomData<&'a ()>,
32871}
32872impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32873    type Target = AccelerationStructureMemoryRequirementsInfoNV;
32874    fn deref(&self) -> &Self::Target {
32875        &self.inner
32876    }
32877}
32878impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32879    fn deref_mut(&mut self) -> &mut Self::Target {
32880        &mut self.inner
32881    }
32882}
32883impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
32884    pub fn ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self {
32885        self.inner.ty = ty;
32886        self
32887    }
32888    pub fn acceleration_structure(
32889        mut self,
32890        acceleration_structure: AccelerationStructureNV,
32891    ) -> Self {
32892        self.inner.acceleration_structure = acceleration_structure;
32893        self
32894    }
32895    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32896    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32897    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
32898    pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV {
32899        self.inner
32900    }
32901}
32902#[repr(C)]
32903#[cfg_attr(feature = "debug", derive(Debug))]
32904#[derive(Copy, Clone)]
32905#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html>"]
32906pub struct PhysicalDeviceAccelerationStructureFeaturesKHR {
32907    pub s_type: StructureType,
32908    pub p_next: *mut c_void,
32909    pub acceleration_structure: Bool32,
32910    pub acceleration_structure_capture_replay: Bool32,
32911    pub acceleration_structure_indirect_build: Bool32,
32912    pub acceleration_structure_host_commands: Bool32,
32913    pub descriptor_binding_acceleration_structure_update_after_bind: Bool32,
32914}
32915impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR {
32916    fn default() -> Self {
32917        Self {
32918            s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
32919            p_next: ::std::ptr::null_mut(),
32920            acceleration_structure: Bool32::default(),
32921            acceleration_structure_capture_replay: Bool32::default(),
32922            acceleration_structure_indirect_build: Bool32::default(),
32923            acceleration_structure_host_commands: Bool32::default(),
32924            descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(),
32925        }
32926    }
32927}
32928impl PhysicalDeviceAccelerationStructureFeaturesKHR {
32929    pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32930        PhysicalDeviceAccelerationStructureFeaturesKHRBuilder {
32931            inner: Self::default(),
32932            marker: ::std::marker::PhantomData,
32933        }
32934    }
32935}
32936#[repr(transparent)]
32937pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32938    inner: PhysicalDeviceAccelerationStructureFeaturesKHR,
32939    marker: ::std::marker::PhantomData<&'a ()>,
32940}
32941unsafe impl ExtendsPhysicalDeviceFeatures2
32942    for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_>
32943{
32944}
32945unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR {}
32946unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {}
32947unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {}
32948impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32949    type Target = PhysicalDeviceAccelerationStructureFeaturesKHR;
32950    fn deref(&self) -> &Self::Target {
32951        &self.inner
32952    }
32953}
32954impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32955    fn deref_mut(&mut self) -> &mut Self::Target {
32956        &mut self.inner
32957    }
32958}
32959impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
32960    pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self {
32961        self.inner.acceleration_structure = acceleration_structure.into();
32962        self
32963    }
32964    pub fn acceleration_structure_capture_replay(
32965        mut self,
32966        acceleration_structure_capture_replay: bool,
32967    ) -> Self {
32968        self.inner.acceleration_structure_capture_replay =
32969            acceleration_structure_capture_replay.into();
32970        self
32971    }
32972    pub fn acceleration_structure_indirect_build(
32973        mut self,
32974        acceleration_structure_indirect_build: bool,
32975    ) -> Self {
32976        self.inner.acceleration_structure_indirect_build =
32977            acceleration_structure_indirect_build.into();
32978        self
32979    }
32980    pub fn acceleration_structure_host_commands(
32981        mut self,
32982        acceleration_structure_host_commands: bool,
32983    ) -> Self {
32984        self.inner.acceleration_structure_host_commands =
32985            acceleration_structure_host_commands.into();
32986        self
32987    }
32988    pub fn descriptor_binding_acceleration_structure_update_after_bind(
32989        mut self,
32990        descriptor_binding_acceleration_structure_update_after_bind: bool,
32991    ) -> Self {
32992        self.inner
32993            .descriptor_binding_acceleration_structure_update_after_bind =
32994            descriptor_binding_acceleration_structure_update_after_bind.into();
32995        self
32996    }
32997    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32998    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32999    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33000    pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR {
33001        self.inner
33002    }
33003}
33004#[repr(C)]
33005#[cfg_attr(feature = "debug", derive(Debug))]
33006#[derive(Copy, Clone)]
33007#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html>"]
33008pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
33009    pub s_type: StructureType,
33010    pub p_next: *mut c_void,
33011    pub ray_tracing_pipeline: Bool32,
33012    pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32,
33013    pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32,
33014    pub ray_tracing_pipeline_trace_rays_indirect: Bool32,
33015    pub ray_traversal_primitive_culling: Bool32,
33016}
33017impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR {
33018    fn default() -> Self {
33019        Self {
33020            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
33021            p_next: ::std::ptr::null_mut(),
33022            ray_tracing_pipeline: Bool32::default(),
33023            ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(),
33024            ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(),
33025            ray_tracing_pipeline_trace_rays_indirect: Bool32::default(),
33026            ray_traversal_primitive_culling: Bool32::default(),
33027        }
33028    }
33029}
33030impl PhysicalDeviceRayTracingPipelineFeaturesKHR {
33031    pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33032        PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder {
33033            inner: Self::default(),
33034            marker: ::std::marker::PhantomData,
33035        }
33036    }
33037}
33038#[repr(transparent)]
33039pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33040    inner: PhysicalDeviceRayTracingPipelineFeaturesKHR,
33041    marker: ::std::marker::PhantomData<&'a ()>,
33042}
33043unsafe impl ExtendsPhysicalDeviceFeatures2
33044    for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_>
33045{
33046}
33047unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR {}
33048unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {}
33049unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {}
33050impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33051    type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR;
33052    fn deref(&self) -> &Self::Target {
33053        &self.inner
33054    }
33055}
33056impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33057    fn deref_mut(&mut self) -> &mut Self::Target {
33058        &mut self.inner
33059    }
33060}
33061impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
33062    pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self {
33063        self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into();
33064        self
33065    }
33066    pub fn ray_tracing_pipeline_shader_group_handle_capture_replay(
33067        mut self,
33068        ray_tracing_pipeline_shader_group_handle_capture_replay: bool,
33069    ) -> Self {
33070        self.inner
33071            .ray_tracing_pipeline_shader_group_handle_capture_replay =
33072            ray_tracing_pipeline_shader_group_handle_capture_replay.into();
33073        self
33074    }
33075    pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed(
33076        mut self,
33077        ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool,
33078    ) -> Self {
33079        self.inner
33080            .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed =
33081            ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into();
33082        self
33083    }
33084    pub fn ray_tracing_pipeline_trace_rays_indirect(
33085        mut self,
33086        ray_tracing_pipeline_trace_rays_indirect: bool,
33087    ) -> Self {
33088        self.inner.ray_tracing_pipeline_trace_rays_indirect =
33089            ray_tracing_pipeline_trace_rays_indirect.into();
33090        self
33091    }
33092    pub fn ray_traversal_primitive_culling(
33093        mut self,
33094        ray_traversal_primitive_culling: bool,
33095    ) -> Self {
33096        self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into();
33097        self
33098    }
33099    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33100    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33101    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33102    pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR {
33103        self.inner
33104    }
33105}
33106#[repr(C)]
33107#[cfg_attr(feature = "debug", derive(Debug))]
33108#[derive(Copy, Clone)]
33109#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html>"]
33110pub struct PhysicalDeviceRayQueryFeaturesKHR {
33111    pub s_type: StructureType,
33112    pub p_next: *mut c_void,
33113    pub ray_query: Bool32,
33114}
33115impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR {
33116    fn default() -> Self {
33117        Self {
33118            s_type: StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
33119            p_next: ::std::ptr::null_mut(),
33120            ray_query: Bool32::default(),
33121        }
33122    }
33123}
33124impl PhysicalDeviceRayQueryFeaturesKHR {
33125    pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33126        PhysicalDeviceRayQueryFeaturesKHRBuilder {
33127            inner: Self::default(),
33128            marker: ::std::marker::PhantomData,
33129        }
33130    }
33131}
33132#[repr(transparent)]
33133pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33134    inner: PhysicalDeviceRayQueryFeaturesKHR,
33135    marker: ::std::marker::PhantomData<&'a ()>,
33136}
33137unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {}
33138unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR {}
33139unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {}
33140unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {}
33141impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33142    type Target = PhysicalDeviceRayQueryFeaturesKHR;
33143    fn deref(&self) -> &Self::Target {
33144        &self.inner
33145    }
33146}
33147impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33148    fn deref_mut(&mut self) -> &mut Self::Target {
33149        &mut self.inner
33150    }
33151}
33152impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
33153    pub fn ray_query(mut self, ray_query: bool) -> Self {
33154        self.inner.ray_query = ray_query.into();
33155        self
33156    }
33157    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33158    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33159    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33160    pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR {
33161        self.inner
33162    }
33163}
33164#[repr(C)]
33165#[cfg_attr(feature = "debug", derive(Debug))]
33166#[derive(Copy, Clone)]
33167#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html>"]
33168pub struct PhysicalDeviceAccelerationStructurePropertiesKHR {
33169    pub s_type: StructureType,
33170    pub p_next: *mut c_void,
33171    pub max_geometry_count: u64,
33172    pub max_instance_count: u64,
33173    pub max_primitive_count: u64,
33174    pub max_per_stage_descriptor_acceleration_structures: u32,
33175    pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
33176    pub max_descriptor_set_acceleration_structures: u32,
33177    pub max_descriptor_set_update_after_bind_acceleration_structures: u32,
33178    pub min_acceleration_structure_scratch_offset_alignment: u32,
33179}
33180impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR {
33181    fn default() -> Self {
33182        Self {
33183            s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
33184            p_next: ::std::ptr::null_mut(),
33185            max_geometry_count: u64::default(),
33186            max_instance_count: u64::default(),
33187            max_primitive_count: u64::default(),
33188            max_per_stage_descriptor_acceleration_structures: u32::default(),
33189            max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(),
33190            max_descriptor_set_acceleration_structures: u32::default(),
33191            max_descriptor_set_update_after_bind_acceleration_structures: u32::default(),
33192            min_acceleration_structure_scratch_offset_alignment: u32::default(),
33193        }
33194    }
33195}
33196impl PhysicalDeviceAccelerationStructurePropertiesKHR {
33197    pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33198        PhysicalDeviceAccelerationStructurePropertiesKHRBuilder {
33199            inner: Self::default(),
33200            marker: ::std::marker::PhantomData,
33201        }
33202    }
33203}
33204#[repr(transparent)]
33205pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33206    inner: PhysicalDeviceAccelerationStructurePropertiesKHR,
33207    marker: ::std::marker::PhantomData<&'a ()>,
33208}
33209unsafe impl ExtendsPhysicalDeviceProperties2
33210    for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_>
33211{
33212}
33213unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {}
33214impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33215    type Target = PhysicalDeviceAccelerationStructurePropertiesKHR;
33216    fn deref(&self) -> &Self::Target {
33217        &self.inner
33218    }
33219}
33220impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33221    fn deref_mut(&mut self) -> &mut Self::Target {
33222        &mut self.inner
33223    }
33224}
33225impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
33226    pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
33227        self.inner.max_geometry_count = max_geometry_count;
33228        self
33229    }
33230    pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
33231        self.inner.max_instance_count = max_instance_count;
33232        self
33233    }
33234    pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self {
33235        self.inner.max_primitive_count = max_primitive_count;
33236        self
33237    }
33238    pub fn max_per_stage_descriptor_acceleration_structures(
33239        mut self,
33240        max_per_stage_descriptor_acceleration_structures: u32,
33241    ) -> Self {
33242        self.inner.max_per_stage_descriptor_acceleration_structures =
33243            max_per_stage_descriptor_acceleration_structures;
33244        self
33245    }
33246    pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures(
33247        mut self,
33248        max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
33249    ) -> Self {
33250        self.inner
33251            .max_per_stage_descriptor_update_after_bind_acceleration_structures =
33252            max_per_stage_descriptor_update_after_bind_acceleration_structures;
33253        self
33254    }
33255    pub fn max_descriptor_set_acceleration_structures(
33256        mut self,
33257        max_descriptor_set_acceleration_structures: u32,
33258    ) -> Self {
33259        self.inner.max_descriptor_set_acceleration_structures =
33260            max_descriptor_set_acceleration_structures;
33261        self
33262    }
33263    pub fn max_descriptor_set_update_after_bind_acceleration_structures(
33264        mut self,
33265        max_descriptor_set_update_after_bind_acceleration_structures: u32,
33266    ) -> Self {
33267        self.inner
33268            .max_descriptor_set_update_after_bind_acceleration_structures =
33269            max_descriptor_set_update_after_bind_acceleration_structures;
33270        self
33271    }
33272    pub fn min_acceleration_structure_scratch_offset_alignment(
33273        mut self,
33274        min_acceleration_structure_scratch_offset_alignment: u32,
33275    ) -> Self {
33276        self.inner
33277            .min_acceleration_structure_scratch_offset_alignment =
33278            min_acceleration_structure_scratch_offset_alignment;
33279        self
33280    }
33281    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33282    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33283    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33284    pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR {
33285        self.inner
33286    }
33287}
33288#[repr(C)]
33289#[cfg_attr(feature = "debug", derive(Debug))]
33290#[derive(Copy, Clone)]
33291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html>"]
33292pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
33293    pub s_type: StructureType,
33294    pub p_next: *mut c_void,
33295    pub shader_group_handle_size: u32,
33296    pub max_ray_recursion_depth: u32,
33297    pub max_shader_group_stride: u32,
33298    pub shader_group_base_alignment: u32,
33299    pub shader_group_handle_capture_replay_size: u32,
33300    pub max_ray_dispatch_invocation_count: u32,
33301    pub shader_group_handle_alignment: u32,
33302    pub max_ray_hit_attribute_size: u32,
33303}
33304impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR {
33305    fn default() -> Self {
33306        Self {
33307            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
33308            p_next: ::std::ptr::null_mut(),
33309            shader_group_handle_size: u32::default(),
33310            max_ray_recursion_depth: u32::default(),
33311            max_shader_group_stride: u32::default(),
33312            shader_group_base_alignment: u32::default(),
33313            shader_group_handle_capture_replay_size: u32::default(),
33314            max_ray_dispatch_invocation_count: u32::default(),
33315            shader_group_handle_alignment: u32::default(),
33316            max_ray_hit_attribute_size: u32::default(),
33317        }
33318    }
33319}
33320impl PhysicalDeviceRayTracingPipelinePropertiesKHR {
33321    pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33322        PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder {
33323            inner: Self::default(),
33324            marker: ::std::marker::PhantomData,
33325        }
33326    }
33327}
33328#[repr(transparent)]
33329pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33330    inner: PhysicalDeviceRayTracingPipelinePropertiesKHR,
33331    marker: ::std::marker::PhantomData<&'a ()>,
33332}
33333unsafe impl ExtendsPhysicalDeviceProperties2
33334    for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_>
33335{
33336}
33337unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {}
33338impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33339    type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR;
33340    fn deref(&self) -> &Self::Target {
33341        &self.inner
33342    }
33343}
33344impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33345    fn deref_mut(&mut self) -> &mut Self::Target {
33346        &mut self.inner
33347    }
33348}
33349impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
33350    pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
33351        self.inner.shader_group_handle_size = shader_group_handle_size;
33352        self
33353    }
33354    pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self {
33355        self.inner.max_ray_recursion_depth = max_ray_recursion_depth;
33356        self
33357    }
33358    pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
33359        self.inner.max_shader_group_stride = max_shader_group_stride;
33360        self
33361    }
33362    pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
33363        self.inner.shader_group_base_alignment = shader_group_base_alignment;
33364        self
33365    }
33366    pub fn shader_group_handle_capture_replay_size(
33367        mut self,
33368        shader_group_handle_capture_replay_size: u32,
33369    ) -> Self {
33370        self.inner.shader_group_handle_capture_replay_size =
33371            shader_group_handle_capture_replay_size;
33372        self
33373    }
33374    pub fn max_ray_dispatch_invocation_count(
33375        mut self,
33376        max_ray_dispatch_invocation_count: u32,
33377    ) -> Self {
33378        self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count;
33379        self
33380    }
33381    pub fn shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self {
33382        self.inner.shader_group_handle_alignment = shader_group_handle_alignment;
33383        self
33384    }
33385    pub fn max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self {
33386        self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size;
33387        self
33388    }
33389    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33390    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33391    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33392    pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR {
33393        self.inner
33394    }
33395}
33396#[repr(C)]
33397#[cfg_attr(feature = "debug", derive(Debug))]
33398#[derive(Copy, Clone)]
33399#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>"]
33400pub struct PhysicalDeviceRayTracingPropertiesNV {
33401    pub s_type: StructureType,
33402    pub p_next: *mut c_void,
33403    pub shader_group_handle_size: u32,
33404    pub max_recursion_depth: u32,
33405    pub max_shader_group_stride: u32,
33406    pub shader_group_base_alignment: u32,
33407    pub max_geometry_count: u64,
33408    pub max_instance_count: u64,
33409    pub max_triangle_count: u64,
33410    pub max_descriptor_set_acceleration_structures: u32,
33411}
33412impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV {
33413    fn default() -> Self {
33414        Self {
33415            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
33416            p_next: ::std::ptr::null_mut(),
33417            shader_group_handle_size: u32::default(),
33418            max_recursion_depth: u32::default(),
33419            max_shader_group_stride: u32::default(),
33420            shader_group_base_alignment: u32::default(),
33421            max_geometry_count: u64::default(),
33422            max_instance_count: u64::default(),
33423            max_triangle_count: u64::default(),
33424            max_descriptor_set_acceleration_structures: u32::default(),
33425        }
33426    }
33427}
33428impl PhysicalDeviceRayTracingPropertiesNV {
33429    pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33430        PhysicalDeviceRayTracingPropertiesNVBuilder {
33431            inner: Self::default(),
33432            marker: ::std::marker::PhantomData,
33433        }
33434    }
33435}
33436#[repr(transparent)]
33437pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33438    inner: PhysicalDeviceRayTracingPropertiesNV,
33439    marker: ::std::marker::PhantomData<&'a ()>,
33440}
33441unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {}
33442unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {}
33443impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33444    type Target = PhysicalDeviceRayTracingPropertiesNV;
33445    fn deref(&self) -> &Self::Target {
33446        &self.inner
33447    }
33448}
33449impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33450    fn deref_mut(&mut self) -> &mut Self::Target {
33451        &mut self.inner
33452    }
33453}
33454impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
33455    pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
33456        self.inner.shader_group_handle_size = shader_group_handle_size;
33457        self
33458    }
33459    pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
33460        self.inner.max_recursion_depth = max_recursion_depth;
33461        self
33462    }
33463    pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
33464        self.inner.max_shader_group_stride = max_shader_group_stride;
33465        self
33466    }
33467    pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
33468        self.inner.shader_group_base_alignment = shader_group_base_alignment;
33469        self
33470    }
33471    pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
33472        self.inner.max_geometry_count = max_geometry_count;
33473        self
33474    }
33475    pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
33476        self.inner.max_instance_count = max_instance_count;
33477        self
33478    }
33479    pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self {
33480        self.inner.max_triangle_count = max_triangle_count;
33481        self
33482    }
33483    pub fn max_descriptor_set_acceleration_structures(
33484        mut self,
33485        max_descriptor_set_acceleration_structures: u32,
33486    ) -> Self {
33487        self.inner.max_descriptor_set_acceleration_structures =
33488            max_descriptor_set_acceleration_structures;
33489        self
33490    }
33491    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33492    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33493    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33494    pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV {
33495        self.inner
33496    }
33497}
33498#[repr(C)]
33499#[cfg_attr(feature = "debug", derive(Debug))]
33500#[derive(Copy, Clone, Default)]
33501#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStridedDeviceAddressRegionKHR.html>"]
33502pub struct StridedDeviceAddressRegionKHR {
33503    pub device_address: DeviceAddress,
33504    pub stride: DeviceSize,
33505    pub size: DeviceSize,
33506}
33507impl StridedDeviceAddressRegionKHR {
33508    pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> {
33509        StridedDeviceAddressRegionKHRBuilder {
33510            inner: Self::default(),
33511            marker: ::std::marker::PhantomData,
33512        }
33513    }
33514}
33515#[repr(transparent)]
33516pub struct StridedDeviceAddressRegionKHRBuilder<'a> {
33517    inner: StridedDeviceAddressRegionKHR,
33518    marker: ::std::marker::PhantomData<&'a ()>,
33519}
33520impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> {
33521    type Target = StridedDeviceAddressRegionKHR;
33522    fn deref(&self) -> &Self::Target {
33523        &self.inner
33524    }
33525}
33526impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> {
33527    fn deref_mut(&mut self) -> &mut Self::Target {
33528        &mut self.inner
33529    }
33530}
33531impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> {
33532    pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
33533        self.inner.device_address = device_address;
33534        self
33535    }
33536    pub fn stride(mut self, stride: DeviceSize) -> Self {
33537        self.inner.stride = stride;
33538        self
33539    }
33540    pub fn size(mut self, size: DeviceSize) -> Self {
33541        self.inner.size = size;
33542        self
33543    }
33544    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33545    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33546    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33547    pub fn build(self) -> StridedDeviceAddressRegionKHR {
33548        self.inner
33549    }
33550}
33551#[repr(C)]
33552#[cfg_attr(feature = "debug", derive(Debug))]
33553#[derive(Copy, Clone, Default)]
33554#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommandKHR.html>"]
33555pub struct TraceRaysIndirectCommandKHR {
33556    pub width: u32,
33557    pub height: u32,
33558    pub depth: u32,
33559}
33560impl TraceRaysIndirectCommandKHR {
33561    pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> {
33562        TraceRaysIndirectCommandKHRBuilder {
33563            inner: Self::default(),
33564            marker: ::std::marker::PhantomData,
33565        }
33566    }
33567}
33568#[repr(transparent)]
33569pub struct TraceRaysIndirectCommandKHRBuilder<'a> {
33570    inner: TraceRaysIndirectCommandKHR,
33571    marker: ::std::marker::PhantomData<&'a ()>,
33572}
33573impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> {
33574    type Target = TraceRaysIndirectCommandKHR;
33575    fn deref(&self) -> &Self::Target {
33576        &self.inner
33577    }
33578}
33579impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> {
33580    fn deref_mut(&mut self) -> &mut Self::Target {
33581        &mut self.inner
33582    }
33583}
33584impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> {
33585    pub fn width(mut self, width: u32) -> Self {
33586        self.inner.width = width;
33587        self
33588    }
33589    pub fn height(mut self, height: u32) -> Self {
33590        self.inner.height = height;
33591        self
33592    }
33593    pub fn depth(mut self, depth: u32) -> Self {
33594        self.inner.depth = depth;
33595        self
33596    }
33597    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33598    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33599    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33600    pub fn build(self) -> TraceRaysIndirectCommandKHR {
33601        self.inner
33602    }
33603}
33604#[repr(C)]
33605#[cfg_attr(feature = "debug", derive(Debug))]
33606#[derive(Copy, Clone)]
33607#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html>"]
33608pub struct DrmFormatModifierPropertiesListEXT {
33609    pub s_type: StructureType,
33610    pub p_next: *mut c_void,
33611    pub drm_format_modifier_count: u32,
33612    pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
33613}
33614impl ::std::default::Default for DrmFormatModifierPropertiesListEXT {
33615    fn default() -> Self {
33616        Self {
33617            s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
33618            p_next: ::std::ptr::null_mut(),
33619            drm_format_modifier_count: u32::default(),
33620            p_drm_format_modifier_properties: ::std::ptr::null_mut(),
33621        }
33622    }
33623}
33624impl DrmFormatModifierPropertiesListEXT {
33625    pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
33626        DrmFormatModifierPropertiesListEXTBuilder {
33627            inner: Self::default(),
33628            marker: ::std::marker::PhantomData,
33629        }
33630    }
33631}
33632#[repr(transparent)]
33633pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> {
33634    inner: DrmFormatModifierPropertiesListEXT,
33635    marker: ::std::marker::PhantomData<&'a ()>,
33636}
33637unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {}
33638unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {}
33639impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> {
33640    type Target = DrmFormatModifierPropertiesListEXT;
33641    fn deref(&self) -> &Self::Target {
33642        &self.inner
33643    }
33644}
33645impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> {
33646    fn deref_mut(&mut self) -> &mut Self::Target {
33647        &mut self.inner
33648    }
33649}
33650impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
33651    pub fn drm_format_modifier_properties(
33652        mut self,
33653        drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT],
33654    ) -> Self {
33655        self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
33656        self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
33657        self
33658    }
33659    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33660    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33661    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33662    pub fn build(self) -> DrmFormatModifierPropertiesListEXT {
33663        self.inner
33664    }
33665}
33666#[repr(C)]
33667#[cfg_attr(feature = "debug", derive(Debug))]
33668#[derive(Copy, Clone, Default)]
33669#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html>"]
33670pub struct DrmFormatModifierPropertiesEXT {
33671    pub drm_format_modifier: u64,
33672    pub drm_format_modifier_plane_count: u32,
33673    pub drm_format_modifier_tiling_features: FormatFeatureFlags,
33674}
33675impl DrmFormatModifierPropertiesEXT {
33676    pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> {
33677        DrmFormatModifierPropertiesEXTBuilder {
33678            inner: Self::default(),
33679            marker: ::std::marker::PhantomData,
33680        }
33681    }
33682}
33683#[repr(transparent)]
33684pub struct DrmFormatModifierPropertiesEXTBuilder<'a> {
33685    inner: DrmFormatModifierPropertiesEXT,
33686    marker: ::std::marker::PhantomData<&'a ()>,
33687}
33688impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> {
33689    type Target = DrmFormatModifierPropertiesEXT;
33690    fn deref(&self) -> &Self::Target {
33691        &self.inner
33692    }
33693}
33694impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> {
33695    fn deref_mut(&mut self) -> &mut Self::Target {
33696        &mut self.inner
33697    }
33698}
33699impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> {
33700    pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33701        self.inner.drm_format_modifier = drm_format_modifier;
33702        self
33703    }
33704    pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
33705        self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
33706        self
33707    }
33708    pub fn drm_format_modifier_tiling_features(
33709        mut self,
33710        drm_format_modifier_tiling_features: FormatFeatureFlags,
33711    ) -> Self {
33712        self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
33713        self
33714    }
33715    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33716    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33717    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33718    pub fn build(self) -> DrmFormatModifierPropertiesEXT {
33719        self.inner
33720    }
33721}
33722#[repr(C)]
33723#[cfg_attr(feature = "debug", derive(Debug))]
33724#[derive(Copy, Clone)]
33725#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>"]
33726pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
33727    pub s_type: StructureType,
33728    pub p_next: *const c_void,
33729    pub drm_format_modifier: u64,
33730    pub sharing_mode: SharingMode,
33731    pub queue_family_index_count: u32,
33732    pub p_queue_family_indices: *const u32,
33733}
33734impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
33735    fn default() -> Self {
33736        Self {
33737            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
33738            p_next: ::std::ptr::null(),
33739            drm_format_modifier: u64::default(),
33740            sharing_mode: SharingMode::default(),
33741            queue_family_index_count: u32::default(),
33742            p_queue_family_indices: ::std::ptr::null(),
33743        }
33744    }
33745}
33746impl PhysicalDeviceImageDrmFormatModifierInfoEXT {
33747    pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33748        PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder {
33749            inner: Self::default(),
33750            marker: ::std::marker::PhantomData,
33751        }
33752    }
33753}
33754#[repr(transparent)]
33755pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33756    inner: PhysicalDeviceImageDrmFormatModifierInfoEXT,
33757    marker: ::std::marker::PhantomData<&'a ()>,
33758}
33759unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
33760    for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_>
33761{
33762}
33763unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {}
33764impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33765    type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT;
33766    fn deref(&self) -> &Self::Target {
33767        &self.inner
33768    }
33769}
33770impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33771    fn deref_mut(&mut self) -> &mut Self::Target {
33772        &mut self.inner
33773    }
33774}
33775impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
33776    pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33777        self.inner.drm_format_modifier = drm_format_modifier;
33778        self
33779    }
33780    pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
33781        self.inner.sharing_mode = sharing_mode;
33782        self
33783    }
33784    pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
33785        self.inner.queue_family_index_count = queue_family_indices.len() as _;
33786        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
33787        self
33788    }
33789    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33790    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33791    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33792    pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
33793        self.inner
33794    }
33795}
33796#[repr(C)]
33797#[cfg_attr(feature = "debug", derive(Debug))]
33798#[derive(Copy, Clone)]
33799#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>"]
33800pub struct ImageDrmFormatModifierListCreateInfoEXT {
33801    pub s_type: StructureType,
33802    pub p_next: *const c_void,
33803    pub drm_format_modifier_count: u32,
33804    pub p_drm_format_modifiers: *const u64,
33805}
33806impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT {
33807    fn default() -> Self {
33808        Self {
33809            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
33810            p_next: ::std::ptr::null(),
33811            drm_format_modifier_count: u32::default(),
33812            p_drm_format_modifiers: ::std::ptr::null(),
33813        }
33814    }
33815}
33816impl ImageDrmFormatModifierListCreateInfoEXT {
33817    pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33818        ImageDrmFormatModifierListCreateInfoEXTBuilder {
33819            inner: Self::default(),
33820            marker: ::std::marker::PhantomData,
33821        }
33822    }
33823}
33824#[repr(transparent)]
33825pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33826    inner: ImageDrmFormatModifierListCreateInfoEXT,
33827    marker: ::std::marker::PhantomData<&'a ()>,
33828}
33829unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {}
33830unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {}
33831impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33832    type Target = ImageDrmFormatModifierListCreateInfoEXT;
33833    fn deref(&self) -> &Self::Target {
33834        &self.inner
33835    }
33836}
33837impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33838    fn deref_mut(&mut self) -> &mut Self::Target {
33839        &mut self.inner
33840    }
33841}
33842impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
33843    pub fn drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self {
33844        self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _;
33845        self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr();
33846        self
33847    }
33848    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33849    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33850    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33851    pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT {
33852        self.inner
33853    }
33854}
33855#[repr(C)]
33856#[cfg_attr(feature = "debug", derive(Debug))]
33857#[derive(Copy, Clone)]
33858#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>"]
33859pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
33860    pub s_type: StructureType,
33861    pub p_next: *const c_void,
33862    pub drm_format_modifier: u64,
33863    pub drm_format_modifier_plane_count: u32,
33864    pub p_plane_layouts: *const SubresourceLayout,
33865}
33866impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
33867    fn default() -> Self {
33868        Self {
33869            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
33870            p_next: ::std::ptr::null(),
33871            drm_format_modifier: u64::default(),
33872            drm_format_modifier_plane_count: u32::default(),
33873            p_plane_layouts: ::std::ptr::null(),
33874        }
33875    }
33876}
33877impl ImageDrmFormatModifierExplicitCreateInfoEXT {
33878    pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33879        ImageDrmFormatModifierExplicitCreateInfoEXTBuilder {
33880            inner: Self::default(),
33881            marker: ::std::marker::PhantomData,
33882        }
33883    }
33884}
33885#[repr(transparent)]
33886pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33887    inner: ImageDrmFormatModifierExplicitCreateInfoEXT,
33888    marker: ::std::marker::PhantomData<&'a ()>,
33889}
33890unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {}
33891unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {}
33892impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33893    type Target = ImageDrmFormatModifierExplicitCreateInfoEXT;
33894    fn deref(&self) -> &Self::Target {
33895        &self.inner
33896    }
33897}
33898impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33899    fn deref_mut(&mut self) -> &mut Self::Target {
33900        &mut self.inner
33901    }
33902}
33903impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
33904    pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33905        self.inner.drm_format_modifier = drm_format_modifier;
33906        self
33907    }
33908    pub fn plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self {
33909        self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _;
33910        self.inner.p_plane_layouts = plane_layouts.as_ptr();
33911        self
33912    }
33913    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33914    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33915    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33916    pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT {
33917        self.inner
33918    }
33919}
33920#[repr(C)]
33921#[cfg_attr(feature = "debug", derive(Debug))]
33922#[derive(Copy, Clone)]
33923#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html>"]
33924pub struct ImageDrmFormatModifierPropertiesEXT {
33925    pub s_type: StructureType,
33926    pub p_next: *mut c_void,
33927    pub drm_format_modifier: u64,
33928}
33929impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT {
33930    fn default() -> Self {
33931        Self {
33932            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
33933            p_next: ::std::ptr::null_mut(),
33934            drm_format_modifier: u64::default(),
33935        }
33936    }
33937}
33938impl ImageDrmFormatModifierPropertiesEXT {
33939    pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33940        ImageDrmFormatModifierPropertiesEXTBuilder {
33941            inner: Self::default(),
33942            marker: ::std::marker::PhantomData,
33943        }
33944    }
33945}
33946#[repr(transparent)]
33947pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33948    inner: ImageDrmFormatModifierPropertiesEXT,
33949    marker: ::std::marker::PhantomData<&'a ()>,
33950}
33951impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33952    type Target = ImageDrmFormatModifierPropertiesEXT;
33953    fn deref(&self) -> &Self::Target {
33954        &self.inner
33955    }
33956}
33957impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33958    fn deref_mut(&mut self) -> &mut Self::Target {
33959        &mut self.inner
33960    }
33961}
33962impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
33963    pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
33964        self.inner.drm_format_modifier = drm_format_modifier;
33965        self
33966    }
33967    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33968    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33969    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
33970    pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT {
33971        self.inner
33972    }
33973}
33974#[repr(C)]
33975#[cfg_attr(feature = "debug", derive(Debug))]
33976#[derive(Copy, Clone)]
33977#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageStencilUsageCreateInfo.html>"]
33978pub struct ImageStencilUsageCreateInfo {
33979    pub s_type: StructureType,
33980    pub p_next: *const c_void,
33981    pub stencil_usage: ImageUsageFlags,
33982}
33983impl ::std::default::Default for ImageStencilUsageCreateInfo {
33984    fn default() -> Self {
33985        Self {
33986            s_type: StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO,
33987            p_next: ::std::ptr::null(),
33988            stencil_usage: ImageUsageFlags::default(),
33989        }
33990    }
33991}
33992impl ImageStencilUsageCreateInfo {
33993    pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> {
33994        ImageStencilUsageCreateInfoBuilder {
33995            inner: Self::default(),
33996            marker: ::std::marker::PhantomData,
33997        }
33998    }
33999}
34000#[repr(transparent)]
34001pub struct ImageStencilUsageCreateInfoBuilder<'a> {
34002    inner: ImageStencilUsageCreateInfo,
34003    marker: ::std::marker::PhantomData<&'a ()>,
34004}
34005unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {}
34006unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {}
34007unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {}
34008unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {}
34009impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> {
34010    type Target = ImageStencilUsageCreateInfo;
34011    fn deref(&self) -> &Self::Target {
34012        &self.inner
34013    }
34014}
34015impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> {
34016    fn deref_mut(&mut self) -> &mut Self::Target {
34017        &mut self.inner
34018    }
34019}
34020impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
34021    pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self {
34022        self.inner.stencil_usage = stencil_usage;
34023        self
34024    }
34025    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34026    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34027    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34028    pub fn build(self) -> ImageStencilUsageCreateInfo {
34029        self.inner
34030    }
34031}
34032#[repr(C)]
34033#[cfg_attr(feature = "debug", derive(Debug))]
34034#[derive(Copy, Clone)]
34035#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>"]
34036pub struct DeviceMemoryOverallocationCreateInfoAMD {
34037    pub s_type: StructureType,
34038    pub p_next: *const c_void,
34039    pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
34040}
34041impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD {
34042    fn default() -> Self {
34043        Self {
34044            s_type: StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
34045            p_next: ::std::ptr::null(),
34046            overallocation_behavior: MemoryOverallocationBehaviorAMD::default(),
34047        }
34048    }
34049}
34050impl DeviceMemoryOverallocationCreateInfoAMD {
34051    pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34052        DeviceMemoryOverallocationCreateInfoAMDBuilder {
34053            inner: Self::default(),
34054            marker: ::std::marker::PhantomData,
34055        }
34056    }
34057}
34058#[repr(transparent)]
34059pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34060    inner: DeviceMemoryOverallocationCreateInfoAMD,
34061    marker: ::std::marker::PhantomData<&'a ()>,
34062}
34063unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {}
34064unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {}
34065impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34066    type Target = DeviceMemoryOverallocationCreateInfoAMD;
34067    fn deref(&self) -> &Self::Target {
34068        &self.inner
34069    }
34070}
34071impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34072    fn deref_mut(&mut self) -> &mut Self::Target {
34073        &mut self.inner
34074    }
34075}
34076impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
34077    pub fn overallocation_behavior(
34078        mut self,
34079        overallocation_behavior: MemoryOverallocationBehaviorAMD,
34080    ) -> Self {
34081        self.inner.overallocation_behavior = overallocation_behavior;
34082        self
34083    }
34084    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34085    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34086    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34087    pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD {
34088        self.inner
34089    }
34090}
34091#[repr(C)]
34092#[cfg_attr(feature = "debug", derive(Debug))]
34093#[derive(Copy, Clone)]
34094#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>"]
34095pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
34096    pub s_type: StructureType,
34097    pub p_next: *mut c_void,
34098    pub fragment_density_map: Bool32,
34099    pub fragment_density_map_dynamic: Bool32,
34100    pub fragment_density_map_non_subsampled_images: Bool32,
34101}
34102impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
34103    fn default() -> Self {
34104        Self {
34105            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
34106            p_next: ::std::ptr::null_mut(),
34107            fragment_density_map: Bool32::default(),
34108            fragment_density_map_dynamic: Bool32::default(),
34109            fragment_density_map_non_subsampled_images: Bool32::default(),
34110        }
34111    }
34112}
34113impl PhysicalDeviceFragmentDensityMapFeaturesEXT {
34114    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34115        PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder {
34116            inner: Self::default(),
34117            marker: ::std::marker::PhantomData,
34118        }
34119    }
34120}
34121#[repr(transparent)]
34122pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34123    inner: PhysicalDeviceFragmentDensityMapFeaturesEXT,
34124    marker: ::std::marker::PhantomData<&'a ()>,
34125}
34126unsafe impl ExtendsPhysicalDeviceFeatures2
34127    for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_>
34128{
34129}
34130unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
34131unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {}
34132unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
34133impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34134    type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT;
34135    fn deref(&self) -> &Self::Target {
34136        &self.inner
34137    }
34138}
34139impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34140    fn deref_mut(&mut self) -> &mut Self::Target {
34141        &mut self.inner
34142    }
34143}
34144impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
34145    pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self {
34146        self.inner.fragment_density_map = fragment_density_map.into();
34147        self
34148    }
34149    pub fn fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self {
34150        self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into();
34151        self
34152    }
34153    pub fn fragment_density_map_non_subsampled_images(
34154        mut self,
34155        fragment_density_map_non_subsampled_images: bool,
34156    ) -> Self {
34157        self.inner.fragment_density_map_non_subsampled_images =
34158            fragment_density_map_non_subsampled_images.into();
34159        self
34160    }
34161    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34162    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34163    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34164    pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
34165        self.inner
34166    }
34167}
34168#[repr(C)]
34169#[cfg_attr(feature = "debug", derive(Debug))]
34170#[derive(Copy, Clone)]
34171#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html>"]
34172pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34173    pub s_type: StructureType,
34174    pub p_next: *mut c_void,
34175    pub fragment_density_map_deferred: Bool32,
34176}
34177impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34178    fn default() -> Self {
34179        Self {
34180            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
34181            p_next: ::std::ptr::null_mut(),
34182            fragment_density_map_deferred: Bool32::default(),
34183        }
34184    }
34185}
34186impl PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34187    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34188        PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder {
34189            inner: Self::default(),
34190            marker: ::std::marker::PhantomData,
34191        }
34192    }
34193}
34194#[repr(transparent)]
34195pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34196    inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT,
34197    marker: ::std::marker::PhantomData<&'a ()>,
34198}
34199unsafe impl ExtendsPhysicalDeviceFeatures2
34200    for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_>
34201{
34202}
34203unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT {}
34204unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {}
34205unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {}
34206impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34207    type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
34208    fn deref(&self) -> &Self::Target {
34209        &self.inner
34210    }
34211}
34212impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34213    fn deref_mut(&mut self) -> &mut Self::Target {
34214        &mut self.inner
34215    }
34216}
34217impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
34218    pub fn fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self {
34219        self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into();
34220        self
34221    }
34222    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34223    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34224    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34225    pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT {
34226        self.inner
34227    }
34228}
34229#[repr(C)]
34230#[cfg_attr(feature = "debug", derive(Debug))]
34231#[derive(Copy, Clone)]
34232#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html>"]
34233pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34234    pub s_type: StructureType,
34235    pub p_next: *mut c_void,
34236    pub fragment_density_map_offset: Bool32,
34237}
34238impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34239    fn default() -> Self {
34240        Self {
34241            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
34242            p_next: ::std::ptr::null_mut(),
34243            fragment_density_map_offset: Bool32::default(),
34244        }
34245    }
34246}
34247impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34248    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34249        PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder {
34250            inner: Self::default(),
34251            marker: ::std::marker::PhantomData,
34252        }
34253    }
34254}
34255#[repr(transparent)]
34256pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34257    inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM,
34258    marker: ::std::marker::PhantomData<&'a ()>,
34259}
34260unsafe impl ExtendsPhysicalDeviceFeatures2
34261    for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
34262{
34263}
34264unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
34265unsafe impl ExtendsDeviceCreateInfo
34266    for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
34267{
34268}
34269unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
34270impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34271    type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
34272    fn deref(&self) -> &Self::Target {
34273        &self.inner
34274    }
34275}
34276impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34277    fn deref_mut(&mut self) -> &mut Self::Target {
34278        &mut self.inner
34279    }
34280}
34281impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
34282    pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self {
34283        self.inner.fragment_density_map_offset = fragment_density_map_offset.into();
34284        self
34285    }
34286    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34287    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34288    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34289    pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
34290        self.inner
34291    }
34292}
34293#[repr(C)]
34294#[cfg_attr(feature = "debug", derive(Debug))]
34295#[derive(Copy, Clone)]
34296#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>"]
34297pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
34298    pub s_type: StructureType,
34299    pub p_next: *mut c_void,
34300    pub min_fragment_density_texel_size: Extent2D,
34301    pub max_fragment_density_texel_size: Extent2D,
34302    pub fragment_density_invocations: Bool32,
34303}
34304impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
34305    fn default() -> Self {
34306        Self {
34307            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
34308            p_next: ::std::ptr::null_mut(),
34309            min_fragment_density_texel_size: Extent2D::default(),
34310            max_fragment_density_texel_size: Extent2D::default(),
34311            fragment_density_invocations: Bool32::default(),
34312        }
34313    }
34314}
34315impl PhysicalDeviceFragmentDensityMapPropertiesEXT {
34316    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34317        PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder {
34318            inner: Self::default(),
34319            marker: ::std::marker::PhantomData,
34320        }
34321    }
34322}
34323#[repr(transparent)]
34324pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34325    inner: PhysicalDeviceFragmentDensityMapPropertiesEXT,
34326    marker: ::std::marker::PhantomData<&'a ()>,
34327}
34328unsafe impl ExtendsPhysicalDeviceProperties2
34329    for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_>
34330{
34331}
34332unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {}
34333impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34334    type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT;
34335    fn deref(&self) -> &Self::Target {
34336        &self.inner
34337    }
34338}
34339impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34340    fn deref_mut(&mut self) -> &mut Self::Target {
34341        &mut self.inner
34342    }
34343}
34344impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
34345    pub fn min_fragment_density_texel_size(
34346        mut self,
34347        min_fragment_density_texel_size: Extent2D,
34348    ) -> Self {
34349        self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size;
34350        self
34351    }
34352    pub fn max_fragment_density_texel_size(
34353        mut self,
34354        max_fragment_density_texel_size: Extent2D,
34355    ) -> Self {
34356        self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size;
34357        self
34358    }
34359    pub fn fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self {
34360        self.inner.fragment_density_invocations = fragment_density_invocations.into();
34361        self
34362    }
34363    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34364    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34365    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34366    pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
34367        self.inner
34368    }
34369}
34370#[repr(C)]
34371#[cfg_attr(feature = "debug", derive(Debug))]
34372#[derive(Copy, Clone)]
34373#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html>"]
34374pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34375    pub s_type: StructureType,
34376    pub p_next: *mut c_void,
34377    pub subsampled_loads: Bool32,
34378    pub subsampled_coarse_reconstruction_early_access: Bool32,
34379    pub max_subsampled_array_layers: u32,
34380    pub max_descriptor_set_subsampled_samplers: u32,
34381}
34382impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34383    fn default() -> Self {
34384        Self {
34385            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
34386            p_next: ::std::ptr::null_mut(),
34387            subsampled_loads: Bool32::default(),
34388            subsampled_coarse_reconstruction_early_access: Bool32::default(),
34389            max_subsampled_array_layers: u32::default(),
34390            max_descriptor_set_subsampled_samplers: u32::default(),
34391        }
34392    }
34393}
34394impl PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34395    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34396        PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder {
34397            inner: Self::default(),
34398            marker: ::std::marker::PhantomData,
34399        }
34400    }
34401}
34402#[repr(transparent)]
34403pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34404    inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT,
34405    marker: ::std::marker::PhantomData<&'a ()>,
34406}
34407unsafe impl ExtendsPhysicalDeviceProperties2
34408    for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_>
34409{
34410}
34411unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {}
34412impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34413    type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
34414    fn deref(&self) -> &Self::Target {
34415        &self.inner
34416    }
34417}
34418impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34419    fn deref_mut(&mut self) -> &mut Self::Target {
34420        &mut self.inner
34421    }
34422}
34423impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
34424    pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self {
34425        self.inner.subsampled_loads = subsampled_loads.into();
34426        self
34427    }
34428    pub fn subsampled_coarse_reconstruction_early_access(
34429        mut self,
34430        subsampled_coarse_reconstruction_early_access: bool,
34431    ) -> Self {
34432        self.inner.subsampled_coarse_reconstruction_early_access =
34433            subsampled_coarse_reconstruction_early_access.into();
34434        self
34435    }
34436    pub fn max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self {
34437        self.inner.max_subsampled_array_layers = max_subsampled_array_layers;
34438        self
34439    }
34440    pub fn max_descriptor_set_subsampled_samplers(
34441        mut self,
34442        max_descriptor_set_subsampled_samplers: u32,
34443    ) -> Self {
34444        self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers;
34445        self
34446    }
34447    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34448    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34449    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34450    pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT {
34451        self.inner
34452    }
34453}
34454#[repr(C)]
34455#[cfg_attr(feature = "debug", derive(Debug))]
34456#[derive(Copy, Clone)]
34457#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html>"]
34458pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34459    pub s_type: StructureType,
34460    pub p_next: *mut c_void,
34461    pub fragment_density_offset_granularity: Extent2D,
34462}
34463impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34464    fn default() -> Self {
34465        Self {
34466            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
34467            p_next: ::std::ptr::null_mut(),
34468            fragment_density_offset_granularity: Extent2D::default(),
34469        }
34470    }
34471}
34472impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34473    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34474        PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder {
34475            inner: Self::default(),
34476            marker: ::std::marker::PhantomData,
34477        }
34478    }
34479}
34480#[repr(transparent)]
34481pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34482    inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM,
34483    marker: ::std::marker::PhantomData<&'a ()>,
34484}
34485unsafe impl ExtendsPhysicalDeviceProperties2
34486    for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_>
34487{
34488}
34489unsafe impl ExtendsPhysicalDeviceProperties2
34490    for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
34491{
34492}
34493impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34494    type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
34495    fn deref(&self) -> &Self::Target {
34496        &self.inner
34497    }
34498}
34499impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34500    fn deref_mut(&mut self) -> &mut Self::Target {
34501        &mut self.inner
34502    }
34503}
34504impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
34505    pub fn fragment_density_offset_granularity(
34506        mut self,
34507        fragment_density_offset_granularity: Extent2D,
34508    ) -> Self {
34509        self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity;
34510        self
34511    }
34512    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34513    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34514    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34515    pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
34516        self.inner
34517    }
34518}
34519#[repr(C)]
34520#[cfg_attr(feature = "debug", derive(Debug))]
34521#[derive(Copy, Clone)]
34522#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>"]
34523pub struct RenderPassFragmentDensityMapCreateInfoEXT {
34524    pub s_type: StructureType,
34525    pub p_next: *const c_void,
34526    pub fragment_density_map_attachment: AttachmentReference,
34527}
34528impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT {
34529    fn default() -> Self {
34530        Self {
34531            s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
34532            p_next: ::std::ptr::null(),
34533            fragment_density_map_attachment: AttachmentReference::default(),
34534        }
34535    }
34536}
34537impl RenderPassFragmentDensityMapCreateInfoEXT {
34538    pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34539        RenderPassFragmentDensityMapCreateInfoEXTBuilder {
34540            inner: Self::default(),
34541            marker: ::std::marker::PhantomData,
34542        }
34543    }
34544}
34545#[repr(transparent)]
34546pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34547    inner: RenderPassFragmentDensityMapCreateInfoEXT,
34548    marker: ::std::marker::PhantomData<&'a ()>,
34549}
34550unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
34551unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {}
34552unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
34553unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {}
34554impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34555    type Target = RenderPassFragmentDensityMapCreateInfoEXT;
34556    fn deref(&self) -> &Self::Target {
34557        &self.inner
34558    }
34559}
34560impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34561    fn deref_mut(&mut self) -> &mut Self::Target {
34562        &mut self.inner
34563    }
34564}
34565impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
34566    pub fn fragment_density_map_attachment(
34567        mut self,
34568        fragment_density_map_attachment: AttachmentReference,
34569    ) -> Self {
34570        self.inner.fragment_density_map_attachment = fragment_density_map_attachment;
34571        self
34572    }
34573    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34574    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34575    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34576    pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT {
34577        self.inner
34578    }
34579}
34580#[repr(C)]
34581#[cfg_attr(feature = "debug", derive(Debug))]
34582#[derive(Copy, Clone)]
34583#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html>"]
34584pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM {
34585    pub s_type: StructureType,
34586    pub p_next: *const c_void,
34587    pub fragment_density_offset_count: u32,
34588    pub p_fragment_density_offsets: *const Offset2D,
34589}
34590impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM {
34591    fn default() -> Self {
34592        Self {
34593            s_type: StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
34594            p_next: ::std::ptr::null(),
34595            fragment_density_offset_count: u32::default(),
34596            p_fragment_density_offsets: ::std::ptr::null(),
34597        }
34598    }
34599}
34600impl SubpassFragmentDensityMapOffsetEndInfoQCOM {
34601    pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34602        SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder {
34603            inner: Self::default(),
34604            marker: ::std::marker::PhantomData,
34605        }
34606    }
34607}
34608#[repr(transparent)]
34609pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34610    inner: SubpassFragmentDensityMapOffsetEndInfoQCOM,
34611    marker: ::std::marker::PhantomData<&'a ()>,
34612}
34613unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {}
34614unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {}
34615impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34616    type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM;
34617    fn deref(&self) -> &Self::Target {
34618        &self.inner
34619    }
34620}
34621impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34622    fn deref_mut(&mut self) -> &mut Self::Target {
34623        &mut self.inner
34624    }
34625}
34626impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
34627    pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self {
34628        self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _;
34629        self.inner.p_fragment_density_offsets = fragment_density_offsets.as_ptr();
34630        self
34631    }
34632    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34633    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34634    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34635    pub fn build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM {
34636        self.inner
34637    }
34638}
34639#[repr(C)]
34640#[cfg_attr(feature = "debug", derive(Debug))]
34641#[derive(Copy, Clone)]
34642#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>"]
34643pub struct PhysicalDeviceScalarBlockLayoutFeatures {
34644    pub s_type: StructureType,
34645    pub p_next: *mut c_void,
34646    pub scalar_block_layout: Bool32,
34647}
34648impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures {
34649    fn default() -> Self {
34650        Self {
34651            s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
34652            p_next: ::std::ptr::null_mut(),
34653            scalar_block_layout: Bool32::default(),
34654        }
34655    }
34656}
34657impl PhysicalDeviceScalarBlockLayoutFeatures {
34658    pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34659        PhysicalDeviceScalarBlockLayoutFeaturesBuilder {
34660            inner: Self::default(),
34661            marker: ::std::marker::PhantomData,
34662        }
34663    }
34664}
34665#[repr(transparent)]
34666pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34667    inner: PhysicalDeviceScalarBlockLayoutFeatures,
34668    marker: ::std::marker::PhantomData<&'a ()>,
34669}
34670unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
34671unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures {}
34672unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
34673unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {}
34674impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34675    type Target = PhysicalDeviceScalarBlockLayoutFeatures;
34676    fn deref(&self) -> &Self::Target {
34677        &self.inner
34678    }
34679}
34680impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34681    fn deref_mut(&mut self) -> &mut Self::Target {
34682        &mut self.inner
34683    }
34684}
34685impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
34686    pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
34687        self.inner.scalar_block_layout = scalar_block_layout.into();
34688        self
34689    }
34690    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34691    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34692    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34693    pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures {
34694        self.inner
34695    }
34696}
34697#[repr(C)]
34698#[cfg_attr(feature = "debug", derive(Debug))]
34699#[derive(Copy, Clone)]
34700#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html>"]
34701pub struct SurfaceProtectedCapabilitiesKHR {
34702    pub s_type: StructureType,
34703    pub p_next: *const c_void,
34704    pub supports_protected: Bool32,
34705}
34706impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR {
34707    fn default() -> Self {
34708        Self {
34709            s_type: StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR,
34710            p_next: ::std::ptr::null(),
34711            supports_protected: Bool32::default(),
34712        }
34713    }
34714}
34715impl SurfaceProtectedCapabilitiesKHR {
34716    pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34717        SurfaceProtectedCapabilitiesKHRBuilder {
34718            inner: Self::default(),
34719            marker: ::std::marker::PhantomData,
34720        }
34721    }
34722}
34723#[repr(transparent)]
34724pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34725    inner: SurfaceProtectedCapabilitiesKHR,
34726    marker: ::std::marker::PhantomData<&'a ()>,
34727}
34728unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {}
34729unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {}
34730impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34731    type Target = SurfaceProtectedCapabilitiesKHR;
34732    fn deref(&self) -> &Self::Target {
34733        &self.inner
34734    }
34735}
34736impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34737    fn deref_mut(&mut self) -> &mut Self::Target {
34738        &mut self.inner
34739    }
34740}
34741impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
34742    pub fn supports_protected(mut self, supports_protected: bool) -> Self {
34743        self.inner.supports_protected = supports_protected.into();
34744        self
34745    }
34746    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34747    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34748    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34749    pub fn build(self) -> SurfaceProtectedCapabilitiesKHR {
34750        self.inner
34751    }
34752}
34753#[repr(C)]
34754#[cfg_attr(feature = "debug", derive(Debug))]
34755#[derive(Copy, Clone)]
34756#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>"]
34757pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
34758    pub s_type: StructureType,
34759    pub p_next: *mut c_void,
34760    pub uniform_buffer_standard_layout: Bool32,
34761}
34762impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures {
34763    fn default() -> Self {
34764        Self {
34765            s_type: StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
34766            p_next: ::std::ptr::null_mut(),
34767            uniform_buffer_standard_layout: Bool32::default(),
34768        }
34769    }
34770}
34771impl PhysicalDeviceUniformBufferStandardLayoutFeatures {
34772    pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34773        PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder {
34774            inner: Self::default(),
34775            marker: ::std::marker::PhantomData,
34776        }
34777    }
34778}
34779#[repr(transparent)]
34780pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34781    inner: PhysicalDeviceUniformBufferStandardLayoutFeatures,
34782    marker: ::std::marker::PhantomData<&'a ()>,
34783}
34784unsafe impl ExtendsPhysicalDeviceFeatures2
34785    for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
34786{
34787}
34788unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
34789unsafe impl ExtendsDeviceCreateInfo
34790    for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
34791{
34792}
34793unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
34794impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34795    type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures;
34796    fn deref(&self) -> &Self::Target {
34797        &self.inner
34798    }
34799}
34800impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34801    fn deref_mut(&mut self) -> &mut Self::Target {
34802        &mut self.inner
34803    }
34804}
34805impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
34806    pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
34807        self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
34808        self
34809    }
34810    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34811    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34812    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34813    pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
34814        self.inner
34815    }
34816}
34817#[repr(C)]
34818#[cfg_attr(feature = "debug", derive(Debug))]
34819#[derive(Copy, Clone)]
34820#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>"]
34821pub struct PhysicalDeviceDepthClipEnableFeaturesEXT {
34822    pub s_type: StructureType,
34823    pub p_next: *mut c_void,
34824    pub depth_clip_enable: Bool32,
34825}
34826impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT {
34827    fn default() -> Self {
34828        Self {
34829            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
34830            p_next: ::std::ptr::null_mut(),
34831            depth_clip_enable: Bool32::default(),
34832        }
34833    }
34834}
34835impl PhysicalDeviceDepthClipEnableFeaturesEXT {
34836    pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34837        PhysicalDeviceDepthClipEnableFeaturesEXTBuilder {
34838            inner: Self::default(),
34839            marker: ::std::marker::PhantomData,
34840        }
34841    }
34842}
34843#[repr(transparent)]
34844pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34845    inner: PhysicalDeviceDepthClipEnableFeaturesEXT,
34846    marker: ::std::marker::PhantomData<&'a ()>,
34847}
34848unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
34849unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT {}
34850unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
34851unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {}
34852impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34853    type Target = PhysicalDeviceDepthClipEnableFeaturesEXT;
34854    fn deref(&self) -> &Self::Target {
34855        &self.inner
34856    }
34857}
34858impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34859    fn deref_mut(&mut self) -> &mut Self::Target {
34860        &mut self.inner
34861    }
34862}
34863impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
34864    pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
34865        self.inner.depth_clip_enable = depth_clip_enable.into();
34866        self
34867    }
34868    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34869    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34870    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34871    pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT {
34872        self.inner
34873    }
34874}
34875#[repr(C)]
34876#[cfg_attr(feature = "debug", derive(Debug))]
34877#[derive(Copy, Clone)]
34878#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>"]
34879pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
34880    pub s_type: StructureType,
34881    pub p_next: *const c_void,
34882    pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
34883    pub depth_clip_enable: Bool32,
34884}
34885impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT {
34886    fn default() -> Self {
34887        Self {
34888            s_type: StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
34889            p_next: ::std::ptr::null(),
34890            flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(),
34891            depth_clip_enable: Bool32::default(),
34892        }
34893    }
34894}
34895impl PipelineRasterizationDepthClipStateCreateInfoEXT {
34896    pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34897        PipelineRasterizationDepthClipStateCreateInfoEXTBuilder {
34898            inner: Self::default(),
34899            marker: ::std::marker::PhantomData,
34900        }
34901    }
34902}
34903#[repr(transparent)]
34904pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34905    inner: PipelineRasterizationDepthClipStateCreateInfoEXT,
34906    marker: ::std::marker::PhantomData<&'a ()>,
34907}
34908unsafe impl ExtendsPipelineRasterizationStateCreateInfo
34909    for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_>
34910{
34911}
34912unsafe impl ExtendsPipelineRasterizationStateCreateInfo
34913    for PipelineRasterizationDepthClipStateCreateInfoEXT
34914{
34915}
34916impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34917    type Target = PipelineRasterizationDepthClipStateCreateInfoEXT;
34918    fn deref(&self) -> &Self::Target {
34919        &self.inner
34920    }
34921}
34922impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34923    fn deref_mut(&mut self) -> &mut Self::Target {
34924        &mut self.inner
34925    }
34926}
34927impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
34928    pub fn flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self {
34929        self.inner.flags = flags;
34930        self
34931    }
34932    pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
34933        self.inner.depth_clip_enable = depth_clip_enable.into();
34934        self
34935    }
34936    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34937    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34938    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
34939    pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT {
34940        self.inner
34941    }
34942}
34943#[repr(C)]
34944#[cfg_attr(feature = "debug", derive(Debug))]
34945#[derive(Copy, Clone)]
34946#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>"]
34947pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
34948    pub s_type: StructureType,
34949    pub p_next: *mut c_void,
34950    pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
34951    pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
34952}
34953impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT {
34954    fn default() -> Self {
34955        Self {
34956            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
34957            p_next: ::std::ptr::null_mut(),
34958            heap_budget: unsafe { ::std::mem::zeroed() },
34959            heap_usage: unsafe { ::std::mem::zeroed() },
34960        }
34961    }
34962}
34963impl PhysicalDeviceMemoryBudgetPropertiesEXT {
34964    pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34965        PhysicalDeviceMemoryBudgetPropertiesEXTBuilder {
34966            inner: Self::default(),
34967            marker: ::std::marker::PhantomData,
34968        }
34969    }
34970}
34971#[repr(transparent)]
34972pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34973    inner: PhysicalDeviceMemoryBudgetPropertiesEXT,
34974    marker: ::std::marker::PhantomData<&'a ()>,
34975}
34976unsafe impl ExtendsPhysicalDeviceMemoryProperties2
34977    for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_>
34978{
34979}
34980unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {}
34981impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34982    type Target = PhysicalDeviceMemoryBudgetPropertiesEXT;
34983    fn deref(&self) -> &Self::Target {
34984        &self.inner
34985    }
34986}
34987impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34988    fn deref_mut(&mut self) -> &mut Self::Target {
34989        &mut self.inner
34990    }
34991}
34992impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
34993    pub fn heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
34994        self.inner.heap_budget = heap_budget;
34995        self
34996    }
34997    pub fn heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
34998        self.inner.heap_usage = heap_usage;
34999        self
35000    }
35001    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35002    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35003    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35004    pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT {
35005        self.inner
35006    }
35007}
35008#[repr(C)]
35009#[cfg_attr(feature = "debug", derive(Debug))]
35010#[derive(Copy, Clone)]
35011#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>"]
35012pub struct PhysicalDeviceMemoryPriorityFeaturesEXT {
35013    pub s_type: StructureType,
35014    pub p_next: *mut c_void,
35015    pub memory_priority: Bool32,
35016}
35017impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT {
35018    fn default() -> Self {
35019        Self {
35020            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
35021            p_next: ::std::ptr::null_mut(),
35022            memory_priority: Bool32::default(),
35023        }
35024    }
35025}
35026impl PhysicalDeviceMemoryPriorityFeaturesEXT {
35027    pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35028        PhysicalDeviceMemoryPriorityFeaturesEXTBuilder {
35029            inner: Self::default(),
35030            marker: ::std::marker::PhantomData,
35031        }
35032    }
35033}
35034#[repr(transparent)]
35035pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35036    inner: PhysicalDeviceMemoryPriorityFeaturesEXT,
35037    marker: ::std::marker::PhantomData<&'a ()>,
35038}
35039unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
35040unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {}
35041unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
35042unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {}
35043impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35044    type Target = PhysicalDeviceMemoryPriorityFeaturesEXT;
35045    fn deref(&self) -> &Self::Target {
35046        &self.inner
35047    }
35048}
35049impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35050    fn deref_mut(&mut self) -> &mut Self::Target {
35051        &mut self.inner
35052    }
35053}
35054impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
35055    pub fn memory_priority(mut self, memory_priority: bool) -> Self {
35056        self.inner.memory_priority = memory_priority.into();
35057        self
35058    }
35059    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35060    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35061    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35062    pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT {
35063        self.inner
35064    }
35065}
35066#[repr(C)]
35067#[cfg_attr(feature = "debug", derive(Debug))]
35068#[derive(Copy, Clone)]
35069#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html>"]
35070pub struct MemoryPriorityAllocateInfoEXT {
35071    pub s_type: StructureType,
35072    pub p_next: *const c_void,
35073    pub priority: f32,
35074}
35075impl ::std::default::Default for MemoryPriorityAllocateInfoEXT {
35076    fn default() -> Self {
35077        Self {
35078            s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
35079            p_next: ::std::ptr::null(),
35080            priority: f32::default(),
35081        }
35082    }
35083}
35084impl MemoryPriorityAllocateInfoEXT {
35085    pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
35086        MemoryPriorityAllocateInfoEXTBuilder {
35087            inner: Self::default(),
35088            marker: ::std::marker::PhantomData,
35089        }
35090    }
35091}
35092#[repr(transparent)]
35093pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> {
35094    inner: MemoryPriorityAllocateInfoEXT,
35095    marker: ::std::marker::PhantomData<&'a ()>,
35096}
35097unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {}
35098unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {}
35099impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> {
35100    type Target = MemoryPriorityAllocateInfoEXT;
35101    fn deref(&self) -> &Self::Target {
35102        &self.inner
35103    }
35104}
35105impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> {
35106    fn deref_mut(&mut self) -> &mut Self::Target {
35107        &mut self.inner
35108    }
35109}
35110impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
35111    pub fn priority(mut self, priority: f32) -> Self {
35112        self.inner.priority = priority;
35113        self
35114    }
35115    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35116    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35117    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35118    pub fn build(self) -> MemoryPriorityAllocateInfoEXT {
35119        self.inner
35120    }
35121}
35122#[repr(C)]
35123#[cfg_attr(feature = "debug", derive(Debug))]
35124#[derive(Copy, Clone)]
35125#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html>"]
35126pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35127    pub s_type: StructureType,
35128    pub p_next: *mut c_void,
35129    pub pageable_device_local_memory: Bool32,
35130}
35131impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35132    fn default() -> Self {
35133        Self {
35134            s_type: StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
35135            p_next: ::std::ptr::null_mut(),
35136            pageable_device_local_memory: Bool32::default(),
35137        }
35138    }
35139}
35140impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35141    pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35142        PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder {
35143            inner: Self::default(),
35144            marker: ::std::marker::PhantomData,
35145        }
35146    }
35147}
35148#[repr(transparent)]
35149pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35150    inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT,
35151    marker: ::std::marker::PhantomData<&'a ()>,
35152}
35153unsafe impl ExtendsPhysicalDeviceFeatures2
35154    for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_>
35155{
35156}
35157unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {}
35158unsafe impl ExtendsDeviceCreateInfo
35159    for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_>
35160{
35161}
35162unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {}
35163impl<'a> ::std::ops::Deref for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35164    type Target = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
35165    fn deref(&self) -> &Self::Target {
35166        &self.inner
35167    }
35168}
35169impl<'a> ::std::ops::DerefMut for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35170    fn deref_mut(&mut self) -> &mut Self::Target {
35171        &mut self.inner
35172    }
35173}
35174impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
35175    pub fn pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self {
35176        self.inner.pageable_device_local_memory = pageable_device_local_memory.into();
35177        self
35178    }
35179    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35180    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35181    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35182    pub fn build(self) -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
35183        self.inner
35184    }
35185}
35186#[repr(C)]
35187#[cfg_attr(feature = "debug", derive(Debug))]
35188#[derive(Copy, Clone)]
35189#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>"]
35190pub struct PhysicalDeviceBufferDeviceAddressFeatures {
35191    pub s_type: StructureType,
35192    pub p_next: *mut c_void,
35193    pub buffer_device_address: Bool32,
35194    pub buffer_device_address_capture_replay: Bool32,
35195    pub buffer_device_address_multi_device: Bool32,
35196}
35197impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures {
35198    fn default() -> Self {
35199        Self {
35200            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
35201            p_next: ::std::ptr::null_mut(),
35202            buffer_device_address: Bool32::default(),
35203            buffer_device_address_capture_replay: Bool32::default(),
35204            buffer_device_address_multi_device: Bool32::default(),
35205        }
35206    }
35207}
35208impl PhysicalDeviceBufferDeviceAddressFeatures {
35209    pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35210        PhysicalDeviceBufferDeviceAddressFeaturesBuilder {
35211            inner: Self::default(),
35212            marker: ::std::marker::PhantomData,
35213        }
35214    }
35215}
35216#[repr(transparent)]
35217pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35218    inner: PhysicalDeviceBufferDeviceAddressFeatures,
35219    marker: ::std::marker::PhantomData<&'a ()>,
35220}
35221unsafe impl ExtendsPhysicalDeviceFeatures2
35222    for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_>
35223{
35224}
35225unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures {}
35226unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {}
35227unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {}
35228impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35229    type Target = PhysicalDeviceBufferDeviceAddressFeatures;
35230    fn deref(&self) -> &Self::Target {
35231        &self.inner
35232    }
35233}
35234impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35235    fn deref_mut(&mut self) -> &mut Self::Target {
35236        &mut self.inner
35237    }
35238}
35239impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
35240    pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
35241        self.inner.buffer_device_address = buffer_device_address.into();
35242        self
35243    }
35244    pub fn buffer_device_address_capture_replay(
35245        mut self,
35246        buffer_device_address_capture_replay: bool,
35247    ) -> Self {
35248        self.inner.buffer_device_address_capture_replay =
35249            buffer_device_address_capture_replay.into();
35250        self
35251    }
35252    pub fn buffer_device_address_multi_device(
35253        mut self,
35254        buffer_device_address_multi_device: bool,
35255    ) -> Self {
35256        self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
35257        self
35258    }
35259    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35260    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35261    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35262    pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures {
35263        self.inner
35264    }
35265}
35266#[repr(C)]
35267#[cfg_attr(feature = "debug", derive(Debug))]
35268#[derive(Copy, Clone)]
35269#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>"]
35270pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35271    pub s_type: StructureType,
35272    pub p_next: *mut c_void,
35273    pub buffer_device_address: Bool32,
35274    pub buffer_device_address_capture_replay: Bool32,
35275    pub buffer_device_address_multi_device: Bool32,
35276}
35277impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35278    fn default() -> Self {
35279        Self {
35280            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
35281            p_next: ::std::ptr::null_mut(),
35282            buffer_device_address: Bool32::default(),
35283            buffer_device_address_capture_replay: Bool32::default(),
35284            buffer_device_address_multi_device: Bool32::default(),
35285        }
35286    }
35287}
35288impl PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35289    pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35290        PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder {
35291            inner: Self::default(),
35292            marker: ::std::marker::PhantomData,
35293        }
35294    }
35295}
35296#[repr(transparent)]
35297pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35298    inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT,
35299    marker: ::std::marker::PhantomData<&'a ()>,
35300}
35301unsafe impl ExtendsPhysicalDeviceFeatures2
35302    for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_>
35303{
35304}
35305unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
35306unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {}
35307unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
35308impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35309    type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
35310    fn deref(&self) -> &Self::Target {
35311        &self.inner
35312    }
35313}
35314impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35315    fn deref_mut(&mut self) -> &mut Self::Target {
35316        &mut self.inner
35317    }
35318}
35319impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
35320    pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
35321        self.inner.buffer_device_address = buffer_device_address.into();
35322        self
35323    }
35324    pub fn buffer_device_address_capture_replay(
35325        mut self,
35326        buffer_device_address_capture_replay: bool,
35327    ) -> Self {
35328        self.inner.buffer_device_address_capture_replay =
35329            buffer_device_address_capture_replay.into();
35330        self
35331    }
35332    pub fn buffer_device_address_multi_device(
35333        mut self,
35334        buffer_device_address_multi_device: bool,
35335    ) -> Self {
35336        self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
35337        self
35338    }
35339    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35340    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35341    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35342    pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
35343        self.inner
35344    }
35345}
35346#[repr(C)]
35347#[cfg_attr(feature = "debug", derive(Debug))]
35348#[derive(Copy, Clone)]
35349#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressInfo.html>"]
35350pub struct BufferDeviceAddressInfo {
35351    pub s_type: StructureType,
35352    pub p_next: *const c_void,
35353    pub buffer: Buffer,
35354}
35355impl ::std::default::Default for BufferDeviceAddressInfo {
35356    fn default() -> Self {
35357        Self {
35358            s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO,
35359            p_next: ::std::ptr::null(),
35360            buffer: Buffer::default(),
35361        }
35362    }
35363}
35364impl BufferDeviceAddressInfo {
35365    pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> {
35366        BufferDeviceAddressInfoBuilder {
35367            inner: Self::default(),
35368            marker: ::std::marker::PhantomData,
35369        }
35370    }
35371}
35372#[repr(transparent)]
35373pub struct BufferDeviceAddressInfoBuilder<'a> {
35374    inner: BufferDeviceAddressInfo,
35375    marker: ::std::marker::PhantomData<&'a ()>,
35376}
35377impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> {
35378    type Target = BufferDeviceAddressInfo;
35379    fn deref(&self) -> &Self::Target {
35380        &self.inner
35381    }
35382}
35383impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> {
35384    fn deref_mut(&mut self) -> &mut Self::Target {
35385        &mut self.inner
35386    }
35387}
35388impl<'a> BufferDeviceAddressInfoBuilder<'a> {
35389    pub fn buffer(mut self, buffer: Buffer) -> Self {
35390        self.inner.buffer = buffer;
35391        self
35392    }
35393    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35394    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35395    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35396    pub fn build(self) -> BufferDeviceAddressInfo {
35397        self.inner
35398    }
35399}
35400#[repr(C)]
35401#[cfg_attr(feature = "debug", derive(Debug))]
35402#[derive(Copy, Clone)]
35403#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>"]
35404pub struct BufferOpaqueCaptureAddressCreateInfo {
35405    pub s_type: StructureType,
35406    pub p_next: *const c_void,
35407    pub opaque_capture_address: u64,
35408}
35409impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo {
35410    fn default() -> Self {
35411        Self {
35412            s_type: StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
35413            p_next: ::std::ptr::null(),
35414            opaque_capture_address: u64::default(),
35415        }
35416    }
35417}
35418impl BufferOpaqueCaptureAddressCreateInfo {
35419    pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35420        BufferOpaqueCaptureAddressCreateInfoBuilder {
35421            inner: Self::default(),
35422            marker: ::std::marker::PhantomData,
35423        }
35424    }
35425}
35426#[repr(transparent)]
35427pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35428    inner: BufferOpaqueCaptureAddressCreateInfo,
35429    marker: ::std::marker::PhantomData<&'a ()>,
35430}
35431unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {}
35432unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {}
35433impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35434    type Target = BufferOpaqueCaptureAddressCreateInfo;
35435    fn deref(&self) -> &Self::Target {
35436        &self.inner
35437    }
35438}
35439impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35440    fn deref_mut(&mut self) -> &mut Self::Target {
35441        &mut self.inner
35442    }
35443}
35444impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
35445    pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
35446        self.inner.opaque_capture_address = opaque_capture_address;
35447        self
35448    }
35449    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35450    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35451    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35452    pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo {
35453        self.inner
35454    }
35455}
35456#[repr(C)]
35457#[cfg_attr(feature = "debug", derive(Debug))]
35458#[derive(Copy, Clone)]
35459#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html>"]
35460pub struct BufferDeviceAddressCreateInfoEXT {
35461    pub s_type: StructureType,
35462    pub p_next: *const c_void,
35463    pub device_address: DeviceAddress,
35464}
35465impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT {
35466    fn default() -> Self {
35467        Self {
35468            s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
35469            p_next: ::std::ptr::null(),
35470            device_address: DeviceAddress::default(),
35471        }
35472    }
35473}
35474impl BufferDeviceAddressCreateInfoEXT {
35475    pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35476        BufferDeviceAddressCreateInfoEXTBuilder {
35477            inner: Self::default(),
35478            marker: ::std::marker::PhantomData,
35479        }
35480    }
35481}
35482#[repr(transparent)]
35483pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35484    inner: BufferDeviceAddressCreateInfoEXT,
35485    marker: ::std::marker::PhantomData<&'a ()>,
35486}
35487unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {}
35488unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {}
35489impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35490    type Target = BufferDeviceAddressCreateInfoEXT;
35491    fn deref(&self) -> &Self::Target {
35492        &self.inner
35493    }
35494}
35495impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35496    fn deref_mut(&mut self) -> &mut Self::Target {
35497        &mut self.inner
35498    }
35499}
35500impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
35501    pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
35502        self.inner.device_address = device_address;
35503        self
35504    }
35505    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35506    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35507    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35508    pub fn build(self) -> BufferDeviceAddressCreateInfoEXT {
35509        self.inner
35510    }
35511}
35512#[repr(C)]
35513#[cfg_attr(feature = "debug", derive(Debug))]
35514#[derive(Copy, Clone)]
35515#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>"]
35516pub struct PhysicalDeviceImageViewImageFormatInfoEXT {
35517    pub s_type: StructureType,
35518    pub p_next: *mut c_void,
35519    pub image_view_type: ImageViewType,
35520}
35521impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT {
35522    fn default() -> Self {
35523        Self {
35524            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
35525            p_next: ::std::ptr::null_mut(),
35526            image_view_type: ImageViewType::default(),
35527        }
35528    }
35529}
35530impl PhysicalDeviceImageViewImageFormatInfoEXT {
35531    pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35532        PhysicalDeviceImageViewImageFormatInfoEXTBuilder {
35533            inner: Self::default(),
35534            marker: ::std::marker::PhantomData,
35535        }
35536    }
35537}
35538#[repr(transparent)]
35539pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35540    inner: PhysicalDeviceImageViewImageFormatInfoEXT,
35541    marker: ::std::marker::PhantomData<&'a ()>,
35542}
35543unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
35544    for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_>
35545{
35546}
35547unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {}
35548impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35549    type Target = PhysicalDeviceImageViewImageFormatInfoEXT;
35550    fn deref(&self) -> &Self::Target {
35551        &self.inner
35552    }
35553}
35554impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35555    fn deref_mut(&mut self) -> &mut Self::Target {
35556        &mut self.inner
35557    }
35558}
35559impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
35560    pub fn image_view_type(mut self, image_view_type: ImageViewType) -> Self {
35561        self.inner.image_view_type = image_view_type;
35562        self
35563    }
35564    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35565    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35566    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35567    pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT {
35568        self.inner
35569    }
35570}
35571#[repr(C)]
35572#[cfg_attr(feature = "debug", derive(Debug))]
35573#[derive(Copy, Clone)]
35574#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>"]
35575pub struct FilterCubicImageViewImageFormatPropertiesEXT {
35576    pub s_type: StructureType,
35577    pub p_next: *mut c_void,
35578    pub filter_cubic: Bool32,
35579    pub filter_cubic_minmax: Bool32,
35580}
35581impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT {
35582    fn default() -> Self {
35583        Self {
35584            s_type: StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
35585            p_next: ::std::ptr::null_mut(),
35586            filter_cubic: Bool32::default(),
35587            filter_cubic_minmax: Bool32::default(),
35588        }
35589    }
35590}
35591impl FilterCubicImageViewImageFormatPropertiesEXT {
35592    pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35593        FilterCubicImageViewImageFormatPropertiesEXTBuilder {
35594            inner: Self::default(),
35595            marker: ::std::marker::PhantomData,
35596        }
35597    }
35598}
35599#[repr(transparent)]
35600pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35601    inner: FilterCubicImageViewImageFormatPropertiesEXT,
35602    marker: ::std::marker::PhantomData<&'a ()>,
35603}
35604unsafe impl ExtendsImageFormatProperties2
35605    for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_>
35606{
35607}
35608unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {}
35609impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35610    type Target = FilterCubicImageViewImageFormatPropertiesEXT;
35611    fn deref(&self) -> &Self::Target {
35612        &self.inner
35613    }
35614}
35615impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35616    fn deref_mut(&mut self) -> &mut Self::Target {
35617        &mut self.inner
35618    }
35619}
35620impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
35621    pub fn filter_cubic(mut self, filter_cubic: bool) -> Self {
35622        self.inner.filter_cubic = filter_cubic.into();
35623        self
35624    }
35625    pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self {
35626        self.inner.filter_cubic_minmax = filter_cubic_minmax.into();
35627        self
35628    }
35629    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35630    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35631    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35632    pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT {
35633        self.inner
35634    }
35635}
35636#[repr(C)]
35637#[cfg_attr(feature = "debug", derive(Debug))]
35638#[derive(Copy, Clone)]
35639#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>"]
35640pub struct PhysicalDeviceImagelessFramebufferFeatures {
35641    pub s_type: StructureType,
35642    pub p_next: *mut c_void,
35643    pub imageless_framebuffer: Bool32,
35644}
35645impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures {
35646    fn default() -> Self {
35647        Self {
35648            s_type: StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
35649            p_next: ::std::ptr::null_mut(),
35650            imageless_framebuffer: Bool32::default(),
35651        }
35652    }
35653}
35654impl PhysicalDeviceImagelessFramebufferFeatures {
35655    pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35656        PhysicalDeviceImagelessFramebufferFeaturesBuilder {
35657            inner: Self::default(),
35658            marker: ::std::marker::PhantomData,
35659        }
35660    }
35661}
35662#[repr(transparent)]
35663pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35664    inner: PhysicalDeviceImagelessFramebufferFeatures,
35665    marker: ::std::marker::PhantomData<&'a ()>,
35666}
35667unsafe impl ExtendsPhysicalDeviceFeatures2
35668    for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_>
35669{
35670}
35671unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures {}
35672unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {}
35673unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {}
35674impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35675    type Target = PhysicalDeviceImagelessFramebufferFeatures;
35676    fn deref(&self) -> &Self::Target {
35677        &self.inner
35678    }
35679}
35680impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35681    fn deref_mut(&mut self) -> &mut Self::Target {
35682        &mut self.inner
35683    }
35684}
35685impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
35686    pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
35687        self.inner.imageless_framebuffer = imageless_framebuffer.into();
35688        self
35689    }
35690    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35691    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35692    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35693    pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures {
35694        self.inner
35695    }
35696}
35697#[repr(C)]
35698#[cfg_attr(feature = "debug", derive(Debug))]
35699#[derive(Copy, Clone)]
35700#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html>"]
35701pub struct FramebufferAttachmentsCreateInfo {
35702    pub s_type: StructureType,
35703    pub p_next: *const c_void,
35704    pub attachment_image_info_count: u32,
35705    pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo,
35706}
35707impl ::std::default::Default for FramebufferAttachmentsCreateInfo {
35708    fn default() -> Self {
35709        Self {
35710            s_type: StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
35711            p_next: ::std::ptr::null(),
35712            attachment_image_info_count: u32::default(),
35713            p_attachment_image_infos: ::std::ptr::null(),
35714        }
35715    }
35716}
35717impl FramebufferAttachmentsCreateInfo {
35718    pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> {
35719        FramebufferAttachmentsCreateInfoBuilder {
35720            inner: Self::default(),
35721            marker: ::std::marker::PhantomData,
35722        }
35723    }
35724}
35725#[repr(transparent)]
35726pub struct FramebufferAttachmentsCreateInfoBuilder<'a> {
35727    inner: FramebufferAttachmentsCreateInfo,
35728    marker: ::std::marker::PhantomData<&'a ()>,
35729}
35730unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {}
35731unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {}
35732impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> {
35733    type Target = FramebufferAttachmentsCreateInfo;
35734    fn deref(&self) -> &Self::Target {
35735        &self.inner
35736    }
35737}
35738impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> {
35739    fn deref_mut(&mut self) -> &mut Self::Target {
35740        &mut self.inner
35741    }
35742}
35743impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
35744    pub fn attachment_image_infos(
35745        mut self,
35746        attachment_image_infos: &'a [FramebufferAttachmentImageInfo],
35747    ) -> Self {
35748        self.inner.attachment_image_info_count = attachment_image_infos.len() as _;
35749        self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr();
35750        self
35751    }
35752    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35753    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35754    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35755    pub fn build(self) -> FramebufferAttachmentsCreateInfo {
35756        self.inner
35757    }
35758}
35759#[repr(C)]
35760#[cfg_attr(feature = "debug", derive(Debug))]
35761#[derive(Copy, Clone)]
35762#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentImageInfo.html>"]
35763pub struct FramebufferAttachmentImageInfo {
35764    pub s_type: StructureType,
35765    pub p_next: *const c_void,
35766    pub flags: ImageCreateFlags,
35767    pub usage: ImageUsageFlags,
35768    pub width: u32,
35769    pub height: u32,
35770    pub layer_count: u32,
35771    pub view_format_count: u32,
35772    pub p_view_formats: *const Format,
35773}
35774impl ::std::default::Default for FramebufferAttachmentImageInfo {
35775    fn default() -> Self {
35776        Self {
35777            s_type: StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
35778            p_next: ::std::ptr::null(),
35779            flags: ImageCreateFlags::default(),
35780            usage: ImageUsageFlags::default(),
35781            width: u32::default(),
35782            height: u32::default(),
35783            layer_count: u32::default(),
35784            view_format_count: u32::default(),
35785            p_view_formats: ::std::ptr::null(),
35786        }
35787    }
35788}
35789impl FramebufferAttachmentImageInfo {
35790    pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> {
35791        FramebufferAttachmentImageInfoBuilder {
35792            inner: Self::default(),
35793            marker: ::std::marker::PhantomData,
35794        }
35795    }
35796}
35797#[repr(transparent)]
35798pub struct FramebufferAttachmentImageInfoBuilder<'a> {
35799    inner: FramebufferAttachmentImageInfo,
35800    marker: ::std::marker::PhantomData<&'a ()>,
35801}
35802impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> {
35803    type Target = FramebufferAttachmentImageInfo;
35804    fn deref(&self) -> &Self::Target {
35805        &self.inner
35806    }
35807}
35808impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> {
35809    fn deref_mut(&mut self) -> &mut Self::Target {
35810        &mut self.inner
35811    }
35812}
35813impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
35814    pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
35815        self.inner.flags = flags;
35816        self
35817    }
35818    pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
35819        self.inner.usage = usage;
35820        self
35821    }
35822    pub fn width(mut self, width: u32) -> Self {
35823        self.inner.width = width;
35824        self
35825    }
35826    pub fn height(mut self, height: u32) -> Self {
35827        self.inner.height = height;
35828        self
35829    }
35830    pub fn layer_count(mut self, layer_count: u32) -> Self {
35831        self.inner.layer_count = layer_count;
35832        self
35833    }
35834    pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
35835        self.inner.view_format_count = view_formats.len() as _;
35836        self.inner.p_view_formats = view_formats.as_ptr();
35837        self
35838    }
35839    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35840    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35841    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35842    pub fn build(self) -> FramebufferAttachmentImageInfo {
35843        self.inner
35844    }
35845}
35846#[repr(C)]
35847#[cfg_attr(feature = "debug", derive(Debug))]
35848#[derive(Copy, Clone)]
35849#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassAttachmentBeginInfo.html>"]
35850pub struct RenderPassAttachmentBeginInfo {
35851    pub s_type: StructureType,
35852    pub p_next: *const c_void,
35853    pub attachment_count: u32,
35854    pub p_attachments: *const ImageView,
35855}
35856impl ::std::default::Default for RenderPassAttachmentBeginInfo {
35857    fn default() -> Self {
35858        Self {
35859            s_type: StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO,
35860            p_next: ::std::ptr::null(),
35861            attachment_count: u32::default(),
35862            p_attachments: ::std::ptr::null(),
35863        }
35864    }
35865}
35866impl RenderPassAttachmentBeginInfo {
35867    pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> {
35868        RenderPassAttachmentBeginInfoBuilder {
35869            inner: Self::default(),
35870            marker: ::std::marker::PhantomData,
35871        }
35872    }
35873}
35874#[repr(transparent)]
35875pub struct RenderPassAttachmentBeginInfoBuilder<'a> {
35876    inner: RenderPassAttachmentBeginInfo,
35877    marker: ::std::marker::PhantomData<&'a ()>,
35878}
35879unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {}
35880unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {}
35881impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> {
35882    type Target = RenderPassAttachmentBeginInfo;
35883    fn deref(&self) -> &Self::Target {
35884        &self.inner
35885    }
35886}
35887impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> {
35888    fn deref_mut(&mut self) -> &mut Self::Target {
35889        &mut self.inner
35890    }
35891}
35892impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
35893    pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
35894        self.inner.attachment_count = attachments.len() as _;
35895        self.inner.p_attachments = attachments.as_ptr();
35896        self
35897    }
35898    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35899    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35900    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35901    pub fn build(self) -> RenderPassAttachmentBeginInfo {
35902        self.inner
35903    }
35904}
35905#[repr(C)]
35906#[cfg_attr(feature = "debug", derive(Debug))]
35907#[derive(Copy, Clone)]
35908#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html>"]
35909pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures {
35910    pub s_type: StructureType,
35911    pub p_next: *mut c_void,
35912    pub texture_compression_astc_hdr: Bool32,
35913}
35914impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures {
35915    fn default() -> Self {
35916        Self {
35917            s_type: StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES,
35918            p_next: ::std::ptr::null_mut(),
35919            texture_compression_astc_hdr: Bool32::default(),
35920        }
35921    }
35922}
35923impl PhysicalDeviceTextureCompressionASTCHDRFeatures {
35924    pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35925        PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder {
35926            inner: Self::default(),
35927            marker: ::std::marker::PhantomData,
35928        }
35929    }
35930}
35931#[repr(transparent)]
35932pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35933    inner: PhysicalDeviceTextureCompressionASTCHDRFeatures,
35934    marker: ::std::marker::PhantomData<&'a ()>,
35935}
35936unsafe impl ExtendsPhysicalDeviceFeatures2
35937    for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_>
35938{
35939}
35940unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
35941unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> {}
35942unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
35943impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35944    type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures;
35945    fn deref(&self) -> &Self::Target {
35946        &self.inner
35947    }
35948}
35949impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35950    fn deref_mut(&mut self) -> &mut Self::Target {
35951        &mut self.inner
35952    }
35953}
35954impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
35955    pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
35956        self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
35957        self
35958    }
35959    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35960    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35961    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
35962    pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures {
35963        self.inner
35964    }
35965}
35966#[repr(C)]
35967#[cfg_attr(feature = "debug", derive(Debug))]
35968#[derive(Copy, Clone)]
35969#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>"]
35970pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
35971    pub s_type: StructureType,
35972    pub p_next: *mut c_void,
35973    pub cooperative_matrix: Bool32,
35974    pub cooperative_matrix_robust_buffer_access: Bool32,
35975}
35976impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV {
35977    fn default() -> Self {
35978        Self {
35979            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
35980            p_next: ::std::ptr::null_mut(),
35981            cooperative_matrix: Bool32::default(),
35982            cooperative_matrix_robust_buffer_access: Bool32::default(),
35983        }
35984    }
35985}
35986impl PhysicalDeviceCooperativeMatrixFeaturesNV {
35987    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
35988        PhysicalDeviceCooperativeMatrixFeaturesNVBuilder {
35989            inner: Self::default(),
35990            marker: ::std::marker::PhantomData,
35991        }
35992    }
35993}
35994#[repr(transparent)]
35995pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
35996    inner: PhysicalDeviceCooperativeMatrixFeaturesNV,
35997    marker: ::std::marker::PhantomData<&'a ()>,
35998}
35999unsafe impl ExtendsPhysicalDeviceFeatures2
36000    for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_>
36001{
36002}
36003unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV {}
36004unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {}
36005unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {}
36006impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
36007    type Target = PhysicalDeviceCooperativeMatrixFeaturesNV;
36008    fn deref(&self) -> &Self::Target {
36009        &self.inner
36010    }
36011}
36012impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
36013    fn deref_mut(&mut self) -> &mut Self::Target {
36014        &mut self.inner
36015    }
36016}
36017impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
36018    pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self {
36019        self.inner.cooperative_matrix = cooperative_matrix.into();
36020        self
36021    }
36022    pub fn cooperative_matrix_robust_buffer_access(
36023        mut self,
36024        cooperative_matrix_robust_buffer_access: bool,
36025    ) -> Self {
36026        self.inner.cooperative_matrix_robust_buffer_access =
36027            cooperative_matrix_robust_buffer_access.into();
36028        self
36029    }
36030    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36031    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36032    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36033    pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV {
36034        self.inner
36035    }
36036}
36037#[repr(C)]
36038#[cfg_attr(feature = "debug", derive(Debug))]
36039#[derive(Copy, Clone)]
36040#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
36041pub struct PhysicalDeviceCooperativeMatrixPropertiesNV {
36042    pub s_type: StructureType,
36043    pub p_next: *mut c_void,
36044    pub cooperative_matrix_supported_stages: ShaderStageFlags,
36045}
36046impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV {
36047    fn default() -> Self {
36048        Self {
36049            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
36050            p_next: ::std::ptr::null_mut(),
36051            cooperative_matrix_supported_stages: ShaderStageFlags::default(),
36052        }
36053    }
36054}
36055impl PhysicalDeviceCooperativeMatrixPropertiesNV {
36056    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36057        PhysicalDeviceCooperativeMatrixPropertiesNVBuilder {
36058            inner: Self::default(),
36059            marker: ::std::marker::PhantomData,
36060        }
36061    }
36062}
36063#[repr(transparent)]
36064pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36065    inner: PhysicalDeviceCooperativeMatrixPropertiesNV,
36066    marker: ::std::marker::PhantomData<&'a ()>,
36067}
36068unsafe impl ExtendsPhysicalDeviceProperties2
36069    for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_>
36070{
36071}
36072unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {}
36073impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36074    type Target = PhysicalDeviceCooperativeMatrixPropertiesNV;
36075    fn deref(&self) -> &Self::Target {
36076        &self.inner
36077    }
36078}
36079impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36080    fn deref_mut(&mut self) -> &mut Self::Target {
36081        &mut self.inner
36082    }
36083}
36084impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
36085    pub fn cooperative_matrix_supported_stages(
36086        mut self,
36087        cooperative_matrix_supported_stages: ShaderStageFlags,
36088    ) -> Self {
36089        self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages;
36090        self
36091    }
36092    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36093    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36094    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36095    pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV {
36096        self.inner
36097    }
36098}
36099#[repr(C)]
36100#[cfg_attr(feature = "debug", derive(Debug))]
36101#[derive(Copy, Clone)]
36102#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCooperativeMatrixPropertiesNV.html>"]
36103pub struct CooperativeMatrixPropertiesNV {
36104    pub s_type: StructureType,
36105    pub p_next: *mut c_void,
36106    pub m_size: u32,
36107    pub n_size: u32,
36108    pub k_size: u32,
36109    pub a_type: ComponentTypeNV,
36110    pub b_type: ComponentTypeNV,
36111    pub c_type: ComponentTypeNV,
36112    pub d_type: ComponentTypeNV,
36113    pub scope: ScopeNV,
36114}
36115impl ::std::default::Default for CooperativeMatrixPropertiesNV {
36116    fn default() -> Self {
36117        Self {
36118            s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV,
36119            p_next: ::std::ptr::null_mut(),
36120            m_size: u32::default(),
36121            n_size: u32::default(),
36122            k_size: u32::default(),
36123            a_type: ComponentTypeNV::default(),
36124            b_type: ComponentTypeNV::default(),
36125            c_type: ComponentTypeNV::default(),
36126            d_type: ComponentTypeNV::default(),
36127            scope: ScopeNV::default(),
36128        }
36129    }
36130}
36131impl CooperativeMatrixPropertiesNV {
36132    pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> {
36133        CooperativeMatrixPropertiesNVBuilder {
36134            inner: Self::default(),
36135            marker: ::std::marker::PhantomData,
36136        }
36137    }
36138}
36139#[repr(transparent)]
36140pub struct CooperativeMatrixPropertiesNVBuilder<'a> {
36141    inner: CooperativeMatrixPropertiesNV,
36142    marker: ::std::marker::PhantomData<&'a ()>,
36143}
36144impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> {
36145    type Target = CooperativeMatrixPropertiesNV;
36146    fn deref(&self) -> &Self::Target {
36147        &self.inner
36148    }
36149}
36150impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> {
36151    fn deref_mut(&mut self) -> &mut Self::Target {
36152        &mut self.inner
36153    }
36154}
36155impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
36156    pub fn m_size(mut self, m_size: u32) -> Self {
36157        self.inner.m_size = m_size;
36158        self
36159    }
36160    pub fn n_size(mut self, n_size: u32) -> Self {
36161        self.inner.n_size = n_size;
36162        self
36163    }
36164    pub fn k_size(mut self, k_size: u32) -> Self {
36165        self.inner.k_size = k_size;
36166        self
36167    }
36168    pub fn a_type(mut self, a_type: ComponentTypeNV) -> Self {
36169        self.inner.a_type = a_type;
36170        self
36171    }
36172    pub fn b_type(mut self, b_type: ComponentTypeNV) -> Self {
36173        self.inner.b_type = b_type;
36174        self
36175    }
36176    pub fn c_type(mut self, c_type: ComponentTypeNV) -> Self {
36177        self.inner.c_type = c_type;
36178        self
36179    }
36180    pub fn d_type(mut self, d_type: ComponentTypeNV) -> Self {
36181        self.inner.d_type = d_type;
36182        self
36183    }
36184    pub fn scope(mut self, scope: ScopeNV) -> Self {
36185        self.inner.scope = scope;
36186        self
36187    }
36188    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36189    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36190    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36191    pub fn build(self) -> CooperativeMatrixPropertiesNV {
36192        self.inner
36193    }
36194}
36195#[repr(C)]
36196#[cfg_attr(feature = "debug", derive(Debug))]
36197#[derive(Copy, Clone)]
36198#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>"]
36199pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36200    pub s_type: StructureType,
36201    pub p_next: *mut c_void,
36202    pub ycbcr_image_arrays: Bool32,
36203}
36204impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36205    fn default() -> Self {
36206        Self {
36207            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
36208            p_next: ::std::ptr::null_mut(),
36209            ycbcr_image_arrays: Bool32::default(),
36210        }
36211    }
36212}
36213impl PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36214    pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36215        PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder {
36216            inner: Self::default(),
36217            marker: ::std::marker::PhantomData,
36218        }
36219    }
36220}
36221#[repr(transparent)]
36222pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36223    inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT,
36224    marker: ::std::marker::PhantomData<&'a ()>,
36225}
36226unsafe impl ExtendsPhysicalDeviceFeatures2
36227    for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_>
36228{
36229}
36230unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
36231unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {}
36232unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
36233impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36234    type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
36235    fn deref(&self) -> &Self::Target {
36236        &self.inner
36237    }
36238}
36239impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36240    fn deref_mut(&mut self) -> &mut Self::Target {
36241        &mut self.inner
36242    }
36243}
36244impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
36245    pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self {
36246        self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into();
36247        self
36248    }
36249    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36250    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36251    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36252    pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
36253        self.inner
36254    }
36255}
36256#[repr(C)]
36257#[cfg_attr(feature = "debug", derive(Debug))]
36258#[derive(Copy, Clone)]
36259#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewHandleInfoNVX.html>"]
36260pub struct ImageViewHandleInfoNVX {
36261    pub s_type: StructureType,
36262    pub p_next: *const c_void,
36263    pub image_view: ImageView,
36264    pub descriptor_type: DescriptorType,
36265    pub sampler: Sampler,
36266}
36267impl ::std::default::Default for ImageViewHandleInfoNVX {
36268    fn default() -> Self {
36269        Self {
36270            s_type: StructureType::IMAGE_VIEW_HANDLE_INFO_NVX,
36271            p_next: ::std::ptr::null(),
36272            image_view: ImageView::default(),
36273            descriptor_type: DescriptorType::default(),
36274            sampler: Sampler::default(),
36275        }
36276    }
36277}
36278impl ImageViewHandleInfoNVX {
36279    pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> {
36280        ImageViewHandleInfoNVXBuilder {
36281            inner: Self::default(),
36282            marker: ::std::marker::PhantomData,
36283        }
36284    }
36285}
36286#[repr(transparent)]
36287pub struct ImageViewHandleInfoNVXBuilder<'a> {
36288    inner: ImageViewHandleInfoNVX,
36289    marker: ::std::marker::PhantomData<&'a ()>,
36290}
36291impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> {
36292    type Target = ImageViewHandleInfoNVX;
36293    fn deref(&self) -> &Self::Target {
36294        &self.inner
36295    }
36296}
36297impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> {
36298    fn deref_mut(&mut self) -> &mut Self::Target {
36299        &mut self.inner
36300    }
36301}
36302impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
36303    pub fn image_view(mut self, image_view: ImageView) -> Self {
36304        self.inner.image_view = image_view;
36305        self
36306    }
36307    pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
36308        self.inner.descriptor_type = descriptor_type;
36309        self
36310    }
36311    pub fn sampler(mut self, sampler: Sampler) -> Self {
36312        self.inner.sampler = sampler;
36313        self
36314    }
36315    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36316    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36317    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36318    pub fn build(self) -> ImageViewHandleInfoNVX {
36319        self.inner
36320    }
36321}
36322#[repr(C)]
36323#[cfg_attr(feature = "debug", derive(Debug))]
36324#[derive(Copy, Clone)]
36325#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewAddressPropertiesNVX.html>"]
36326pub struct ImageViewAddressPropertiesNVX {
36327    pub s_type: StructureType,
36328    pub p_next: *mut c_void,
36329    pub device_address: DeviceAddress,
36330    pub size: DeviceSize,
36331}
36332impl ::std::default::Default for ImageViewAddressPropertiesNVX {
36333    fn default() -> Self {
36334        Self {
36335            s_type: StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
36336            p_next: ::std::ptr::null_mut(),
36337            device_address: DeviceAddress::default(),
36338            size: DeviceSize::default(),
36339        }
36340    }
36341}
36342impl ImageViewAddressPropertiesNVX {
36343    pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> {
36344        ImageViewAddressPropertiesNVXBuilder {
36345            inner: Self::default(),
36346            marker: ::std::marker::PhantomData,
36347        }
36348    }
36349}
36350#[repr(transparent)]
36351pub struct ImageViewAddressPropertiesNVXBuilder<'a> {
36352    inner: ImageViewAddressPropertiesNVX,
36353    marker: ::std::marker::PhantomData<&'a ()>,
36354}
36355impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> {
36356    type Target = ImageViewAddressPropertiesNVX;
36357    fn deref(&self) -> &Self::Target {
36358        &self.inner
36359    }
36360}
36361impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> {
36362    fn deref_mut(&mut self) -> &mut Self::Target {
36363        &mut self.inner
36364    }
36365}
36366impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> {
36367    pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
36368        self.inner.device_address = device_address;
36369        self
36370    }
36371    pub fn size(mut self, size: DeviceSize) -> Self {
36372        self.inner.size = size;
36373        self
36374    }
36375    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36376    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36377    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36378    pub fn build(self) -> ImageViewAddressPropertiesNVX {
36379        self.inner
36380    }
36381}
36382#[repr(C)]
36383#[cfg_attr(feature = "debug", derive(Debug))]
36384#[derive(Copy, Clone)]
36385#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentFrameTokenGGP.html>"]
36386pub struct PresentFrameTokenGGP {
36387    pub s_type: StructureType,
36388    pub p_next: *const c_void,
36389    pub frame_token: GgpFrameToken,
36390}
36391impl ::std::default::Default for PresentFrameTokenGGP {
36392    fn default() -> Self {
36393        Self {
36394            s_type: StructureType::PRESENT_FRAME_TOKEN_GGP,
36395            p_next: ::std::ptr::null(),
36396            frame_token: GgpFrameToken::default(),
36397        }
36398    }
36399}
36400impl PresentFrameTokenGGP {
36401    pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> {
36402        PresentFrameTokenGGPBuilder {
36403            inner: Self::default(),
36404            marker: ::std::marker::PhantomData,
36405        }
36406    }
36407}
36408#[repr(transparent)]
36409pub struct PresentFrameTokenGGPBuilder<'a> {
36410    inner: PresentFrameTokenGGP,
36411    marker: ::std::marker::PhantomData<&'a ()>,
36412}
36413unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {}
36414unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {}
36415impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> {
36416    type Target = PresentFrameTokenGGP;
36417    fn deref(&self) -> &Self::Target {
36418        &self.inner
36419    }
36420}
36421impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> {
36422    fn deref_mut(&mut self) -> &mut Self::Target {
36423        &mut self.inner
36424    }
36425}
36426impl<'a> PresentFrameTokenGGPBuilder<'a> {
36427    pub fn frame_token(mut self, frame_token: GgpFrameToken) -> Self {
36428        self.inner.frame_token = frame_token;
36429        self
36430    }
36431    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36432    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36433    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36434    pub fn build(self) -> PresentFrameTokenGGP {
36435        self.inner
36436    }
36437}
36438#[repr(C)]
36439#[cfg_attr(feature = "debug", derive(Debug))]
36440#[derive(Copy, Clone, Default)]
36441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedback.html>"]
36442pub struct PipelineCreationFeedback {
36443    pub flags: PipelineCreationFeedbackFlags,
36444    pub duration: u64,
36445}
36446impl PipelineCreationFeedback {
36447    pub fn builder<'a>() -> PipelineCreationFeedbackBuilder<'a> {
36448        PipelineCreationFeedbackBuilder {
36449            inner: Self::default(),
36450            marker: ::std::marker::PhantomData,
36451        }
36452    }
36453}
36454#[repr(transparent)]
36455pub struct PipelineCreationFeedbackBuilder<'a> {
36456    inner: PipelineCreationFeedback,
36457    marker: ::std::marker::PhantomData<&'a ()>,
36458}
36459impl<'a> ::std::ops::Deref for PipelineCreationFeedbackBuilder<'a> {
36460    type Target = PipelineCreationFeedback;
36461    fn deref(&self) -> &Self::Target {
36462        &self.inner
36463    }
36464}
36465impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackBuilder<'a> {
36466    fn deref_mut(&mut self) -> &mut Self::Target {
36467        &mut self.inner
36468    }
36469}
36470impl<'a> PipelineCreationFeedbackBuilder<'a> {
36471    pub fn flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self {
36472        self.inner.flags = flags;
36473        self
36474    }
36475    pub fn duration(mut self, duration: u64) -> Self {
36476        self.inner.duration = duration;
36477        self
36478    }
36479    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36480    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36481    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36482    pub fn build(self) -> PipelineCreationFeedback {
36483        self.inner
36484    }
36485}
36486#[repr(C)]
36487#[cfg_attr(feature = "debug", derive(Debug))]
36488#[derive(Copy, Clone)]
36489#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackCreateInfo.html>"]
36490pub struct PipelineCreationFeedbackCreateInfo {
36491    pub s_type: StructureType,
36492    pub p_next: *const c_void,
36493    pub p_pipeline_creation_feedback: *mut PipelineCreationFeedback,
36494    pub pipeline_stage_creation_feedback_count: u32,
36495    pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback,
36496}
36497impl ::std::default::Default for PipelineCreationFeedbackCreateInfo {
36498    fn default() -> Self {
36499        Self {
36500            s_type: StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO,
36501            p_next: ::std::ptr::null(),
36502            p_pipeline_creation_feedback: ::std::ptr::null_mut(),
36503            pipeline_stage_creation_feedback_count: u32::default(),
36504            p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(),
36505        }
36506    }
36507}
36508impl PipelineCreationFeedbackCreateInfo {
36509    pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> {
36510        PipelineCreationFeedbackCreateInfoBuilder {
36511            inner: Self::default(),
36512            marker: ::std::marker::PhantomData,
36513        }
36514    }
36515}
36516#[repr(transparent)]
36517pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> {
36518    inner: PipelineCreationFeedbackCreateInfo,
36519    marker: ::std::marker::PhantomData<&'a ()>,
36520}
36521unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
36522unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
36523unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
36524unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
36525unsafe impl ExtendsRayTracingPipelineCreateInfoNV
36526    for PipelineCreationFeedbackCreateInfoBuilder<'_>
36527{
36528}
36529unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo {}
36530unsafe impl ExtendsRayTracingPipelineCreateInfoKHR
36531    for PipelineCreationFeedbackCreateInfoBuilder<'_>
36532{
36533}
36534unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo {}
36535impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> {
36536    type Target = PipelineCreationFeedbackCreateInfo;
36537    fn deref(&self) -> &Self::Target {
36538        &self.inner
36539    }
36540}
36541impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> {
36542    fn deref_mut(&mut self) -> &mut Self::Target {
36543        &mut self.inner
36544    }
36545}
36546impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> {
36547    pub fn pipeline_creation_feedback(
36548        mut self,
36549        pipeline_creation_feedback: &'a mut PipelineCreationFeedback,
36550    ) -> Self {
36551        self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback;
36552        self
36553    }
36554    pub fn pipeline_stage_creation_feedbacks(
36555        mut self,
36556        pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback],
36557    ) -> Self {
36558        self.inner.pipeline_stage_creation_feedback_count =
36559            pipeline_stage_creation_feedbacks.len() as _;
36560        self.inner.p_pipeline_stage_creation_feedbacks =
36561            pipeline_stage_creation_feedbacks.as_mut_ptr();
36562        self
36563    }
36564    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36565    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36566    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36567    pub fn build(self) -> PipelineCreationFeedbackCreateInfo {
36568        self.inner
36569    }
36570}
36571#[repr(C)]
36572#[cfg_attr(feature = "debug", derive(Debug))]
36573#[derive(Copy, Clone)]
36574#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>"]
36575pub struct SurfaceFullScreenExclusiveInfoEXT {
36576    pub s_type: StructureType,
36577    pub p_next: *mut c_void,
36578    pub full_screen_exclusive: FullScreenExclusiveEXT,
36579}
36580impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT {
36581    fn default() -> Self {
36582        Self {
36583            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
36584            p_next: ::std::ptr::null_mut(),
36585            full_screen_exclusive: FullScreenExclusiveEXT::default(),
36586        }
36587    }
36588}
36589impl SurfaceFullScreenExclusiveInfoEXT {
36590    pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36591        SurfaceFullScreenExclusiveInfoEXTBuilder {
36592            inner: Self::default(),
36593            marker: ::std::marker::PhantomData,
36594        }
36595    }
36596}
36597#[repr(transparent)]
36598pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36599    inner: SurfaceFullScreenExclusiveInfoEXT,
36600    marker: ::std::marker::PhantomData<&'a ()>,
36601}
36602unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
36603unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {}
36604unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
36605unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {}
36606impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36607    type Target = SurfaceFullScreenExclusiveInfoEXT;
36608    fn deref(&self) -> &Self::Target {
36609        &self.inner
36610    }
36611}
36612impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36613    fn deref_mut(&mut self) -> &mut Self::Target {
36614        &mut self.inner
36615    }
36616}
36617impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
36618    pub fn full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self {
36619        self.inner.full_screen_exclusive = full_screen_exclusive;
36620        self
36621    }
36622    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36623    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36624    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36625    pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT {
36626        self.inner
36627    }
36628}
36629#[repr(C)]
36630#[cfg_attr(feature = "debug", derive(Debug))]
36631#[derive(Copy, Clone)]
36632#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>"]
36633pub struct SurfaceFullScreenExclusiveWin32InfoEXT {
36634    pub s_type: StructureType,
36635    pub p_next: *const c_void,
36636    pub hmonitor: HMONITOR,
36637}
36638impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT {
36639    fn default() -> Self {
36640        Self {
36641            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
36642            p_next: ::std::ptr::null(),
36643            hmonitor: unsafe { ::std::mem::zeroed() },
36644        }
36645    }
36646}
36647impl SurfaceFullScreenExclusiveWin32InfoEXT {
36648    pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36649        SurfaceFullScreenExclusiveWin32InfoEXTBuilder {
36650            inner: Self::default(),
36651            marker: ::std::marker::PhantomData,
36652        }
36653    }
36654}
36655#[repr(transparent)]
36656pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36657    inner: SurfaceFullScreenExclusiveWin32InfoEXT,
36658    marker: ::std::marker::PhantomData<&'a ()>,
36659}
36660unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR
36661    for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_>
36662{
36663}
36664unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
36665unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {}
36666unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
36667impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36668    type Target = SurfaceFullScreenExclusiveWin32InfoEXT;
36669    fn deref(&self) -> &Self::Target {
36670        &self.inner
36671    }
36672}
36673impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36674    fn deref_mut(&mut self) -> &mut Self::Target {
36675        &mut self.inner
36676    }
36677}
36678impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
36679    pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self {
36680        self.inner.hmonitor = hmonitor;
36681        self
36682    }
36683    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36684    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36685    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36686    pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT {
36687        self.inner
36688    }
36689}
36690#[repr(C)]
36691#[cfg_attr(feature = "debug", derive(Debug))]
36692#[derive(Copy, Clone)]
36693#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>"]
36694pub struct SurfaceCapabilitiesFullScreenExclusiveEXT {
36695    pub s_type: StructureType,
36696    pub p_next: *mut c_void,
36697    pub full_screen_exclusive_supported: Bool32,
36698}
36699impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT {
36700    fn default() -> Self {
36701        Self {
36702            s_type: StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
36703            p_next: ::std::ptr::null_mut(),
36704            full_screen_exclusive_supported: Bool32::default(),
36705        }
36706    }
36707}
36708impl SurfaceCapabilitiesFullScreenExclusiveEXT {
36709    pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36710        SurfaceCapabilitiesFullScreenExclusiveEXTBuilder {
36711            inner: Self::default(),
36712            marker: ::std::marker::PhantomData,
36713        }
36714    }
36715}
36716#[repr(transparent)]
36717pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36718    inner: SurfaceCapabilitiesFullScreenExclusiveEXT,
36719    marker: ::std::marker::PhantomData<&'a ()>,
36720}
36721unsafe impl ExtendsSurfaceCapabilities2KHR
36722    for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_>
36723{
36724}
36725unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {}
36726impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36727    type Target = SurfaceCapabilitiesFullScreenExclusiveEXT;
36728    fn deref(&self) -> &Self::Target {
36729        &self.inner
36730    }
36731}
36732impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36733    fn deref_mut(&mut self) -> &mut Self::Target {
36734        &mut self.inner
36735    }
36736}
36737impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
36738    pub fn full_screen_exclusive_supported(
36739        mut self,
36740        full_screen_exclusive_supported: bool,
36741    ) -> Self {
36742        self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into();
36743        self
36744    }
36745    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36746    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36747    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36748    pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT {
36749        self.inner
36750    }
36751}
36752#[repr(C)]
36753#[cfg_attr(feature = "debug", derive(Debug))]
36754#[derive(Copy, Clone)]
36755#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>"]
36756pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
36757    pub s_type: StructureType,
36758    pub p_next: *mut c_void,
36759    pub performance_counter_query_pools: Bool32,
36760    pub performance_counter_multiple_query_pools: Bool32,
36761}
36762impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR {
36763    fn default() -> Self {
36764        Self {
36765            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
36766            p_next: ::std::ptr::null_mut(),
36767            performance_counter_query_pools: Bool32::default(),
36768            performance_counter_multiple_query_pools: Bool32::default(),
36769        }
36770    }
36771}
36772impl PhysicalDevicePerformanceQueryFeaturesKHR {
36773    pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36774        PhysicalDevicePerformanceQueryFeaturesKHRBuilder {
36775            inner: Self::default(),
36776            marker: ::std::marker::PhantomData,
36777        }
36778    }
36779}
36780#[repr(transparent)]
36781pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36782    inner: PhysicalDevicePerformanceQueryFeaturesKHR,
36783    marker: ::std::marker::PhantomData<&'a ()>,
36784}
36785unsafe impl ExtendsPhysicalDeviceFeatures2
36786    for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_>
36787{
36788}
36789unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR {}
36790unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {}
36791unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {}
36792impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36793    type Target = PhysicalDevicePerformanceQueryFeaturesKHR;
36794    fn deref(&self) -> &Self::Target {
36795        &self.inner
36796    }
36797}
36798impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36799    fn deref_mut(&mut self) -> &mut Self::Target {
36800        &mut self.inner
36801    }
36802}
36803impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
36804    pub fn performance_counter_query_pools(
36805        mut self,
36806        performance_counter_query_pools: bool,
36807    ) -> Self {
36808        self.inner.performance_counter_query_pools = performance_counter_query_pools.into();
36809        self
36810    }
36811    pub fn performance_counter_multiple_query_pools(
36812        mut self,
36813        performance_counter_multiple_query_pools: bool,
36814    ) -> Self {
36815        self.inner.performance_counter_multiple_query_pools =
36816            performance_counter_multiple_query_pools.into();
36817        self
36818    }
36819    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36820    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36821    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36822    pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR {
36823        self.inner
36824    }
36825}
36826#[repr(C)]
36827#[cfg_attr(feature = "debug", derive(Debug))]
36828#[derive(Copy, Clone)]
36829#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>"]
36830pub struct PhysicalDevicePerformanceQueryPropertiesKHR {
36831    pub s_type: StructureType,
36832    pub p_next: *mut c_void,
36833    pub allow_command_buffer_query_copies: Bool32,
36834}
36835impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR {
36836    fn default() -> Self {
36837        Self {
36838            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
36839            p_next: ::std::ptr::null_mut(),
36840            allow_command_buffer_query_copies: Bool32::default(),
36841        }
36842    }
36843}
36844impl PhysicalDevicePerformanceQueryPropertiesKHR {
36845    pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36846        PhysicalDevicePerformanceQueryPropertiesKHRBuilder {
36847            inner: Self::default(),
36848            marker: ::std::marker::PhantomData,
36849        }
36850    }
36851}
36852#[repr(transparent)]
36853pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36854    inner: PhysicalDevicePerformanceQueryPropertiesKHR,
36855    marker: ::std::marker::PhantomData<&'a ()>,
36856}
36857unsafe impl ExtendsPhysicalDeviceProperties2
36858    for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_>
36859{
36860}
36861unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {}
36862impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36863    type Target = PhysicalDevicePerformanceQueryPropertiesKHR;
36864    fn deref(&self) -> &Self::Target {
36865        &self.inner
36866    }
36867}
36868impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36869    fn deref_mut(&mut self) -> &mut Self::Target {
36870        &mut self.inner
36871    }
36872}
36873impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
36874    pub fn allow_command_buffer_query_copies(
36875        mut self,
36876        allow_command_buffer_query_copies: bool,
36877    ) -> Self {
36878        self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into();
36879        self
36880    }
36881    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36882    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36883    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36884    pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR {
36885        self.inner
36886    }
36887}
36888#[repr(C)]
36889#[cfg_attr(feature = "debug", derive(Debug))]
36890#[derive(Copy, Clone)]
36891#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterKHR.html>"]
36892pub struct PerformanceCounterKHR {
36893    pub s_type: StructureType,
36894    pub p_next: *mut c_void,
36895    pub unit: PerformanceCounterUnitKHR,
36896    pub scope: PerformanceCounterScopeKHR,
36897    pub storage: PerformanceCounterStorageKHR,
36898    pub uuid: [u8; UUID_SIZE],
36899}
36900impl ::std::default::Default for PerformanceCounterKHR {
36901    fn default() -> Self {
36902        Self {
36903            s_type: StructureType::PERFORMANCE_COUNTER_KHR,
36904            p_next: ::std::ptr::null_mut(),
36905            unit: PerformanceCounterUnitKHR::default(),
36906            scope: PerformanceCounterScopeKHR::default(),
36907            storage: PerformanceCounterStorageKHR::default(),
36908            uuid: unsafe { ::std::mem::zeroed() },
36909        }
36910    }
36911}
36912impl PerformanceCounterKHR {
36913    pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> {
36914        PerformanceCounterKHRBuilder {
36915            inner: Self::default(),
36916            marker: ::std::marker::PhantomData,
36917        }
36918    }
36919}
36920#[repr(transparent)]
36921pub struct PerformanceCounterKHRBuilder<'a> {
36922    inner: PerformanceCounterKHR,
36923    marker: ::std::marker::PhantomData<&'a ()>,
36924}
36925impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> {
36926    type Target = PerformanceCounterKHR;
36927    fn deref(&self) -> &Self::Target {
36928        &self.inner
36929    }
36930}
36931impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> {
36932    fn deref_mut(&mut self) -> &mut Self::Target {
36933        &mut self.inner
36934    }
36935}
36936impl<'a> PerformanceCounterKHRBuilder<'a> {
36937    pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> Self {
36938        self.inner.unit = unit;
36939        self
36940    }
36941    pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> Self {
36942        self.inner.scope = scope;
36943        self
36944    }
36945    pub fn storage(mut self, storage: PerformanceCounterStorageKHR) -> Self {
36946        self.inner.storage = storage;
36947        self
36948    }
36949    pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self {
36950        self.inner.uuid = uuid;
36951        self
36952    }
36953    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36954    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36955    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
36956    pub fn build(self) -> PerformanceCounterKHR {
36957        self.inner
36958    }
36959}
36960#[repr(C)]
36961#[derive(Copy, Clone)]
36962#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionKHR.html>"]
36963pub struct PerformanceCounterDescriptionKHR {
36964    pub s_type: StructureType,
36965    pub p_next: *mut c_void,
36966    pub flags: PerformanceCounterDescriptionFlagsKHR,
36967    pub name: [c_char; MAX_DESCRIPTION_SIZE],
36968    pub category: [c_char; MAX_DESCRIPTION_SIZE],
36969    pub description: [c_char; MAX_DESCRIPTION_SIZE],
36970}
36971#[cfg(feature = "debug")]
36972impl fmt::Debug for PerformanceCounterDescriptionKHR {
36973    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
36974        fmt.debug_struct("PerformanceCounterDescriptionKHR")
36975            .field("s_type", &self.s_type)
36976            .field("p_next", &self.p_next)
36977            .field("flags", &self.flags)
36978            .field("name", &unsafe {
36979                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
36980            })
36981            .field("category", &unsafe {
36982                ::std::ffi::CStr::from_ptr(self.category.as_ptr())
36983            })
36984            .field("description", &unsafe {
36985                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
36986            })
36987            .finish()
36988    }
36989}
36990impl ::std::default::Default for PerformanceCounterDescriptionKHR {
36991    fn default() -> Self {
36992        Self {
36993            s_type: StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR,
36994            p_next: ::std::ptr::null_mut(),
36995            flags: PerformanceCounterDescriptionFlagsKHR::default(),
36996            name: unsafe { ::std::mem::zeroed() },
36997            category: unsafe { ::std::mem::zeroed() },
36998            description: unsafe { ::std::mem::zeroed() },
36999        }
37000    }
37001}
37002impl PerformanceCounterDescriptionKHR {
37003    pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> {
37004        PerformanceCounterDescriptionKHRBuilder {
37005            inner: Self::default(),
37006            marker: ::std::marker::PhantomData,
37007        }
37008    }
37009}
37010#[repr(transparent)]
37011pub struct PerformanceCounterDescriptionKHRBuilder<'a> {
37012    inner: PerformanceCounterDescriptionKHR,
37013    marker: ::std::marker::PhantomData<&'a ()>,
37014}
37015impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> {
37016    type Target = PerformanceCounterDescriptionKHR;
37017    fn deref(&self) -> &Self::Target {
37018        &self.inner
37019    }
37020}
37021impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> {
37022    fn deref_mut(&mut self) -> &mut Self::Target {
37023        &mut self.inner
37024    }
37025}
37026impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
37027    pub fn flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self {
37028        self.inner.flags = flags;
37029        self
37030    }
37031    pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
37032        self.inner.name = name;
37033        self
37034    }
37035    pub fn category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
37036        self.inner.category = category;
37037        self
37038    }
37039    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
37040        self.inner.description = description;
37041        self
37042    }
37043    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37044    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37045    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37046    pub fn build(self) -> PerformanceCounterDescriptionKHR {
37047        self.inner
37048    }
37049}
37050#[repr(C)]
37051#[cfg_attr(feature = "debug", derive(Debug))]
37052#[derive(Copy, Clone)]
37053#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>"]
37054pub struct QueryPoolPerformanceCreateInfoKHR {
37055    pub s_type: StructureType,
37056    pub p_next: *const c_void,
37057    pub queue_family_index: u32,
37058    pub counter_index_count: u32,
37059    pub p_counter_indices: *const u32,
37060}
37061impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR {
37062    fn default() -> Self {
37063        Self {
37064            s_type: StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
37065            p_next: ::std::ptr::null(),
37066            queue_family_index: u32::default(),
37067            counter_index_count: u32::default(),
37068            p_counter_indices: ::std::ptr::null(),
37069        }
37070    }
37071}
37072impl QueryPoolPerformanceCreateInfoKHR {
37073    pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37074        QueryPoolPerformanceCreateInfoKHRBuilder {
37075            inner: Self::default(),
37076            marker: ::std::marker::PhantomData,
37077        }
37078    }
37079}
37080#[repr(transparent)]
37081pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37082    inner: QueryPoolPerformanceCreateInfoKHR,
37083    marker: ::std::marker::PhantomData<&'a ()>,
37084}
37085unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {}
37086unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {}
37087impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37088    type Target = QueryPoolPerformanceCreateInfoKHR;
37089    fn deref(&self) -> &Self::Target {
37090        &self.inner
37091    }
37092}
37093impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37094    fn deref_mut(&mut self) -> &mut Self::Target {
37095        &mut self.inner
37096    }
37097}
37098impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
37099    pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
37100        self.inner.queue_family_index = queue_family_index;
37101        self
37102    }
37103    pub fn counter_indices(mut self, counter_indices: &'a [u32]) -> Self {
37104        self.inner.counter_index_count = counter_indices.len() as _;
37105        self.inner.p_counter_indices = counter_indices.as_ptr();
37106        self
37107    }
37108    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37109    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37110    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37111    pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR {
37112        self.inner
37113    }
37114}
37115#[repr(C)]
37116#[derive(Copy, Clone)]
37117#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterResultKHR.html>"]
37118pub union PerformanceCounterResultKHR {
37119    pub int32: i32,
37120    pub int64: i64,
37121    pub uint32: u32,
37122    pub uint64: u64,
37123    pub float32: f32,
37124    pub float64: f64,
37125}
37126impl ::std::default::Default for PerformanceCounterResultKHR {
37127    fn default() -> Self {
37128        unsafe { ::std::mem::zeroed() }
37129    }
37130}
37131#[repr(C)]
37132#[cfg_attr(feature = "debug", derive(Debug))]
37133#[derive(Copy, Clone)]
37134#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockInfoKHR.html>"]
37135pub struct AcquireProfilingLockInfoKHR {
37136    pub s_type: StructureType,
37137    pub p_next: *const c_void,
37138    pub flags: AcquireProfilingLockFlagsKHR,
37139    pub timeout: u64,
37140}
37141impl ::std::default::Default for AcquireProfilingLockInfoKHR {
37142    fn default() -> Self {
37143        Self {
37144            s_type: StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR,
37145            p_next: ::std::ptr::null(),
37146            flags: AcquireProfilingLockFlagsKHR::default(),
37147            timeout: u64::default(),
37148        }
37149    }
37150}
37151impl AcquireProfilingLockInfoKHR {
37152    pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> {
37153        AcquireProfilingLockInfoKHRBuilder {
37154            inner: Self::default(),
37155            marker: ::std::marker::PhantomData,
37156        }
37157    }
37158}
37159#[repr(transparent)]
37160pub struct AcquireProfilingLockInfoKHRBuilder<'a> {
37161    inner: AcquireProfilingLockInfoKHR,
37162    marker: ::std::marker::PhantomData<&'a ()>,
37163}
37164impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> {
37165    type Target = AcquireProfilingLockInfoKHR;
37166    fn deref(&self) -> &Self::Target {
37167        &self.inner
37168    }
37169}
37170impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> {
37171    fn deref_mut(&mut self) -> &mut Self::Target {
37172        &mut self.inner
37173    }
37174}
37175impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
37176    pub fn flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self {
37177        self.inner.flags = flags;
37178        self
37179    }
37180    pub fn timeout(mut self, timeout: u64) -> Self {
37181        self.inner.timeout = timeout;
37182        self
37183    }
37184    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37185    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37186    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37187    pub fn build(self) -> AcquireProfilingLockInfoKHR {
37188        self.inner
37189    }
37190}
37191#[repr(C)]
37192#[cfg_attr(feature = "debug", derive(Debug))]
37193#[derive(Copy, Clone)]
37194#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html>"]
37195pub struct PerformanceQuerySubmitInfoKHR {
37196    pub s_type: StructureType,
37197    pub p_next: *const c_void,
37198    pub counter_pass_index: u32,
37199}
37200impl ::std::default::Default for PerformanceQuerySubmitInfoKHR {
37201    fn default() -> Self {
37202        Self {
37203            s_type: StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
37204            p_next: ::std::ptr::null(),
37205            counter_pass_index: u32::default(),
37206        }
37207    }
37208}
37209impl PerformanceQuerySubmitInfoKHR {
37210    pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
37211        PerformanceQuerySubmitInfoKHRBuilder {
37212            inner: Self::default(),
37213            marker: ::std::marker::PhantomData,
37214        }
37215    }
37216}
37217#[repr(transparent)]
37218pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
37219    inner: PerformanceQuerySubmitInfoKHR,
37220    marker: ::std::marker::PhantomData<&'a ()>,
37221}
37222unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
37223unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {}
37224unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
37225unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR {}
37226impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
37227    type Target = PerformanceQuerySubmitInfoKHR;
37228    fn deref(&self) -> &Self::Target {
37229        &self.inner
37230    }
37231}
37232impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> {
37233    fn deref_mut(&mut self) -> &mut Self::Target {
37234        &mut self.inner
37235    }
37236}
37237impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
37238    pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self {
37239        self.inner.counter_pass_index = counter_pass_index;
37240        self
37241    }
37242    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37243    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37244    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37245    pub fn build(self) -> PerformanceQuerySubmitInfoKHR {
37246        self.inner
37247    }
37248}
37249#[repr(C)]
37250#[cfg_attr(feature = "debug", derive(Debug))]
37251#[derive(Copy, Clone)]
37252#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html>"]
37253pub struct HeadlessSurfaceCreateInfoEXT {
37254    pub s_type: StructureType,
37255    pub p_next: *const c_void,
37256    pub flags: HeadlessSurfaceCreateFlagsEXT,
37257}
37258impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT {
37259    fn default() -> Self {
37260        Self {
37261            s_type: StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT,
37262            p_next: ::std::ptr::null(),
37263            flags: HeadlessSurfaceCreateFlagsEXT::default(),
37264        }
37265    }
37266}
37267impl HeadlessSurfaceCreateInfoEXT {
37268    pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37269        HeadlessSurfaceCreateInfoEXTBuilder {
37270            inner: Self::default(),
37271            marker: ::std::marker::PhantomData,
37272        }
37273    }
37274}
37275#[repr(transparent)]
37276pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37277    inner: HeadlessSurfaceCreateInfoEXT,
37278    marker: ::std::marker::PhantomData<&'a ()>,
37279}
37280impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37281    type Target = HeadlessSurfaceCreateInfoEXT;
37282    fn deref(&self) -> &Self::Target {
37283        &self.inner
37284    }
37285}
37286impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37287    fn deref_mut(&mut self) -> &mut Self::Target {
37288        &mut self.inner
37289    }
37290}
37291impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
37292    pub fn flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self {
37293        self.inner.flags = flags;
37294        self
37295    }
37296    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37297    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37298    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37299    pub fn build(self) -> HeadlessSurfaceCreateInfoEXT {
37300        self.inner
37301    }
37302}
37303#[repr(C)]
37304#[cfg_attr(feature = "debug", derive(Debug))]
37305#[derive(Copy, Clone)]
37306#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>"]
37307pub struct PhysicalDeviceCoverageReductionModeFeaturesNV {
37308    pub s_type: StructureType,
37309    pub p_next: *mut c_void,
37310    pub coverage_reduction_mode: Bool32,
37311}
37312impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV {
37313    fn default() -> Self {
37314        Self {
37315            s_type: StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
37316            p_next: ::std::ptr::null_mut(),
37317            coverage_reduction_mode: Bool32::default(),
37318        }
37319    }
37320}
37321impl PhysicalDeviceCoverageReductionModeFeaturesNV {
37322    pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37323        PhysicalDeviceCoverageReductionModeFeaturesNVBuilder {
37324            inner: Self::default(),
37325            marker: ::std::marker::PhantomData,
37326        }
37327    }
37328}
37329#[repr(transparent)]
37330pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37331    inner: PhysicalDeviceCoverageReductionModeFeaturesNV,
37332    marker: ::std::marker::PhantomData<&'a ()>,
37333}
37334unsafe impl ExtendsPhysicalDeviceFeatures2
37335    for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_>
37336{
37337}
37338unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV {}
37339unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {}
37340unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {}
37341impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37342    type Target = PhysicalDeviceCoverageReductionModeFeaturesNV;
37343    fn deref(&self) -> &Self::Target {
37344        &self.inner
37345    }
37346}
37347impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37348    fn deref_mut(&mut self) -> &mut Self::Target {
37349        &mut self.inner
37350    }
37351}
37352impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
37353    pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self {
37354        self.inner.coverage_reduction_mode = coverage_reduction_mode.into();
37355        self
37356    }
37357    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37358    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37359    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37360    pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV {
37361        self.inner
37362    }
37363}
37364#[repr(C)]
37365#[cfg_attr(feature = "debug", derive(Debug))]
37366#[derive(Copy, Clone)]
37367#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>"]
37368pub struct PipelineCoverageReductionStateCreateInfoNV {
37369    pub s_type: StructureType,
37370    pub p_next: *const c_void,
37371    pub flags: PipelineCoverageReductionStateCreateFlagsNV,
37372    pub coverage_reduction_mode: CoverageReductionModeNV,
37373}
37374impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV {
37375    fn default() -> Self {
37376        Self {
37377            s_type: StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
37378            p_next: ::std::ptr::null(),
37379            flags: PipelineCoverageReductionStateCreateFlagsNV::default(),
37380            coverage_reduction_mode: CoverageReductionModeNV::default(),
37381        }
37382    }
37383}
37384impl PipelineCoverageReductionStateCreateInfoNV {
37385    pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37386        PipelineCoverageReductionStateCreateInfoNVBuilder {
37387            inner: Self::default(),
37388            marker: ::std::marker::PhantomData,
37389        }
37390    }
37391}
37392#[repr(transparent)]
37393pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37394    inner: PipelineCoverageReductionStateCreateInfoNV,
37395    marker: ::std::marker::PhantomData<&'a ()>,
37396}
37397unsafe impl ExtendsPipelineMultisampleStateCreateInfo
37398    for PipelineCoverageReductionStateCreateInfoNVBuilder<'_>
37399{
37400}
37401unsafe impl ExtendsPipelineMultisampleStateCreateInfo
37402    for PipelineCoverageReductionStateCreateInfoNV
37403{
37404}
37405impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37406    type Target = PipelineCoverageReductionStateCreateInfoNV;
37407    fn deref(&self) -> &Self::Target {
37408        &self.inner
37409    }
37410}
37411impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37412    fn deref_mut(&mut self) -> &mut Self::Target {
37413        &mut self.inner
37414    }
37415}
37416impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
37417    pub fn flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self {
37418        self.inner.flags = flags;
37419        self
37420    }
37421    pub fn coverage_reduction_mode(
37422        mut self,
37423        coverage_reduction_mode: CoverageReductionModeNV,
37424    ) -> Self {
37425        self.inner.coverage_reduction_mode = coverage_reduction_mode;
37426        self
37427    }
37428    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37429    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37430    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37431    pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV {
37432        self.inner
37433    }
37434}
37435#[repr(C)]
37436#[cfg_attr(feature = "debug", derive(Debug))]
37437#[derive(Copy, Clone)]
37438#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html>"]
37439pub struct FramebufferMixedSamplesCombinationNV {
37440    pub s_type: StructureType,
37441    pub p_next: *mut c_void,
37442    pub coverage_reduction_mode: CoverageReductionModeNV,
37443    pub rasterization_samples: SampleCountFlags,
37444    pub depth_stencil_samples: SampleCountFlags,
37445    pub color_samples: SampleCountFlags,
37446}
37447impl ::std::default::Default for FramebufferMixedSamplesCombinationNV {
37448    fn default() -> Self {
37449        Self {
37450            s_type: StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
37451            p_next: ::std::ptr::null_mut(),
37452            coverage_reduction_mode: CoverageReductionModeNV::default(),
37453            rasterization_samples: SampleCountFlags::default(),
37454            depth_stencil_samples: SampleCountFlags::default(),
37455            color_samples: SampleCountFlags::default(),
37456        }
37457    }
37458}
37459impl FramebufferMixedSamplesCombinationNV {
37460    pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
37461        FramebufferMixedSamplesCombinationNVBuilder {
37462            inner: Self::default(),
37463            marker: ::std::marker::PhantomData,
37464        }
37465    }
37466}
37467#[repr(transparent)]
37468pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> {
37469    inner: FramebufferMixedSamplesCombinationNV,
37470    marker: ::std::marker::PhantomData<&'a ()>,
37471}
37472impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> {
37473    type Target = FramebufferMixedSamplesCombinationNV;
37474    fn deref(&self) -> &Self::Target {
37475        &self.inner
37476    }
37477}
37478impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> {
37479    fn deref_mut(&mut self) -> &mut Self::Target {
37480        &mut self.inner
37481    }
37482}
37483impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
37484    pub fn coverage_reduction_mode(
37485        mut self,
37486        coverage_reduction_mode: CoverageReductionModeNV,
37487    ) -> Self {
37488        self.inner.coverage_reduction_mode = coverage_reduction_mode;
37489        self
37490    }
37491    pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
37492        self.inner.rasterization_samples = rasterization_samples;
37493        self
37494    }
37495    pub fn depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self {
37496        self.inner.depth_stencil_samples = depth_stencil_samples;
37497        self
37498    }
37499    pub fn color_samples(mut self, color_samples: SampleCountFlags) -> Self {
37500        self.inner.color_samples = color_samples;
37501        self
37502    }
37503    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37504    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37505    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37506    pub fn build(self) -> FramebufferMixedSamplesCombinationNV {
37507        self.inner
37508    }
37509}
37510#[repr(C)]
37511#[cfg_attr(feature = "debug", derive(Debug))]
37512#[derive(Copy, Clone)]
37513#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>"]
37514pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37515    pub s_type: StructureType,
37516    pub p_next: *mut c_void,
37517    pub shader_integer_functions2: Bool32,
37518}
37519impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37520    fn default() -> Self {
37521        Self {
37522            s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
37523            p_next: ::std::ptr::null_mut(),
37524            shader_integer_functions2: Bool32::default(),
37525        }
37526    }
37527}
37528impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37529    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37530        PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder {
37531            inner: Self::default(),
37532            marker: ::std::marker::PhantomData,
37533        }
37534    }
37535}
37536#[repr(transparent)]
37537pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37538    inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
37539    marker: ::std::marker::PhantomData<&'a ()>,
37540}
37541unsafe impl ExtendsPhysicalDeviceFeatures2
37542    for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
37543{
37544}
37545unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
37546unsafe impl ExtendsDeviceCreateInfo
37547    for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
37548{
37549}
37550unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
37551impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37552    type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
37553    fn deref(&self) -> &Self::Target {
37554        &self.inner
37555    }
37556}
37557impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37558    fn deref_mut(&mut self) -> &mut Self::Target {
37559        &mut self.inner
37560    }
37561}
37562impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
37563    pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self {
37564        self.inner.shader_integer_functions2 = shader_integer_functions2.into();
37565        self
37566    }
37567    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37568    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37569    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37570    pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
37571        self.inner
37572    }
37573}
37574#[repr(C)]
37575#[derive(Copy, Clone)]
37576#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueDataINTEL.html>"]
37577pub union PerformanceValueDataINTEL {
37578    pub value32: u32,
37579    pub value64: u64,
37580    pub value_float: f32,
37581    pub value_bool: Bool32,
37582    pub value_string: *const c_char,
37583}
37584impl ::std::default::Default for PerformanceValueDataINTEL {
37585    fn default() -> Self {
37586        unsafe { ::std::mem::zeroed() }
37587    }
37588}
37589#[repr(C)]
37590#[derive(Copy, Clone, Default)]
37591#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueINTEL.html>"]
37592pub struct PerformanceValueINTEL {
37593    pub ty: PerformanceValueTypeINTEL,
37594    pub data: PerformanceValueDataINTEL,
37595}
37596#[cfg(feature = "debug")]
37597impl fmt::Debug for PerformanceValueINTEL {
37598    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
37599        fmt.debug_struct("PerformanceValueINTEL")
37600            .field("ty", &self.ty)
37601            .field("data", &"union")
37602            .finish()
37603    }
37604}
37605impl PerformanceValueINTEL {
37606    pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> {
37607        PerformanceValueINTELBuilder {
37608            inner: Self::default(),
37609            marker: ::std::marker::PhantomData,
37610        }
37611    }
37612}
37613#[repr(transparent)]
37614pub struct PerformanceValueINTELBuilder<'a> {
37615    inner: PerformanceValueINTEL,
37616    marker: ::std::marker::PhantomData<&'a ()>,
37617}
37618impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> {
37619    type Target = PerformanceValueINTEL;
37620    fn deref(&self) -> &Self::Target {
37621        &self.inner
37622    }
37623}
37624impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> {
37625    fn deref_mut(&mut self) -> &mut Self::Target {
37626        &mut self.inner
37627    }
37628}
37629impl<'a> PerformanceValueINTELBuilder<'a> {
37630    pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> Self {
37631        self.inner.ty = ty;
37632        self
37633    }
37634    pub fn data(mut self, data: PerformanceValueDataINTEL) -> Self {
37635        self.inner.data = data;
37636        self
37637    }
37638    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37639    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37640    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37641    pub fn build(self) -> PerformanceValueINTEL {
37642        self.inner
37643    }
37644}
37645#[repr(C)]
37646#[cfg_attr(feature = "debug", derive(Debug))]
37647#[derive(Copy, Clone)]
37648#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html>"]
37649pub struct InitializePerformanceApiInfoINTEL {
37650    pub s_type: StructureType,
37651    pub p_next: *const c_void,
37652    pub p_user_data: *mut c_void,
37653}
37654impl ::std::default::Default for InitializePerformanceApiInfoINTEL {
37655    fn default() -> Self {
37656        Self {
37657            s_type: StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL,
37658            p_next: ::std::ptr::null(),
37659            p_user_data: ::std::ptr::null_mut(),
37660        }
37661    }
37662}
37663impl InitializePerformanceApiInfoINTEL {
37664    pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> {
37665        InitializePerformanceApiInfoINTELBuilder {
37666            inner: Self::default(),
37667            marker: ::std::marker::PhantomData,
37668        }
37669    }
37670}
37671#[repr(transparent)]
37672pub struct InitializePerformanceApiInfoINTELBuilder<'a> {
37673    inner: InitializePerformanceApiInfoINTEL,
37674    marker: ::std::marker::PhantomData<&'a ()>,
37675}
37676impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> {
37677    type Target = InitializePerformanceApiInfoINTEL;
37678    fn deref(&self) -> &Self::Target {
37679        &self.inner
37680    }
37681}
37682impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> {
37683    fn deref_mut(&mut self) -> &mut Self::Target {
37684        &mut self.inner
37685    }
37686}
37687impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
37688    pub fn user_data(mut self, user_data: *mut c_void) -> Self {
37689        self.inner.p_user_data = user_data;
37690        self
37691    }
37692    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37693    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37694    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37695    pub fn build(self) -> InitializePerformanceApiInfoINTEL {
37696        self.inner
37697    }
37698}
37699#[repr(C)]
37700#[cfg_attr(feature = "debug", derive(Debug))]
37701#[derive(Copy, Clone)]
37702#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>"]
37703pub struct QueryPoolPerformanceQueryCreateInfoINTEL {
37704    pub s_type: StructureType,
37705    pub p_next: *const c_void,
37706    pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
37707}
37708impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL {
37709    fn default() -> Self {
37710        Self {
37711            s_type: StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
37712            p_next: ::std::ptr::null(),
37713            performance_counters_sampling: QueryPoolSamplingModeINTEL::default(),
37714        }
37715    }
37716}
37717impl QueryPoolPerformanceQueryCreateInfoINTEL {
37718    pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37719        QueryPoolPerformanceQueryCreateInfoINTELBuilder {
37720            inner: Self::default(),
37721            marker: ::std::marker::PhantomData,
37722        }
37723    }
37724}
37725#[repr(transparent)]
37726pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37727    inner: QueryPoolPerformanceQueryCreateInfoINTEL,
37728    marker: ::std::marker::PhantomData<&'a ()>,
37729}
37730unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {}
37731unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {}
37732impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37733    type Target = QueryPoolPerformanceQueryCreateInfoINTEL;
37734    fn deref(&self) -> &Self::Target {
37735        &self.inner
37736    }
37737}
37738impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37739    fn deref_mut(&mut self) -> &mut Self::Target {
37740        &mut self.inner
37741    }
37742}
37743impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
37744    pub fn performance_counters_sampling(
37745        mut self,
37746        performance_counters_sampling: QueryPoolSamplingModeINTEL,
37747    ) -> Self {
37748        self.inner.performance_counters_sampling = performance_counters_sampling;
37749        self
37750    }
37751    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37752    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37753    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37754    pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL {
37755        self.inner
37756    }
37757}
37758#[repr(C)]
37759#[cfg_attr(feature = "debug", derive(Debug))]
37760#[derive(Copy, Clone)]
37761#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceMarkerInfoINTEL.html>"]
37762pub struct PerformanceMarkerInfoINTEL {
37763    pub s_type: StructureType,
37764    pub p_next: *const c_void,
37765    pub marker: u64,
37766}
37767impl ::std::default::Default for PerformanceMarkerInfoINTEL {
37768    fn default() -> Self {
37769        Self {
37770            s_type: StructureType::PERFORMANCE_MARKER_INFO_INTEL,
37771            p_next: ::std::ptr::null(),
37772            marker: u64::default(),
37773        }
37774    }
37775}
37776impl PerformanceMarkerInfoINTEL {
37777    pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> {
37778        PerformanceMarkerInfoINTELBuilder {
37779            inner: Self::default(),
37780            marker: ::std::marker::PhantomData,
37781        }
37782    }
37783}
37784#[repr(transparent)]
37785pub struct PerformanceMarkerInfoINTELBuilder<'a> {
37786    inner: PerformanceMarkerInfoINTEL,
37787    marker: ::std::marker::PhantomData<&'a ()>,
37788}
37789impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> {
37790    type Target = PerformanceMarkerInfoINTEL;
37791    fn deref(&self) -> &Self::Target {
37792        &self.inner
37793    }
37794}
37795impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> {
37796    fn deref_mut(&mut self) -> &mut Self::Target {
37797        &mut self.inner
37798    }
37799}
37800impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
37801    pub fn marker(mut self, marker: u64) -> Self {
37802        self.inner.marker = marker;
37803        self
37804    }
37805    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37806    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37807    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37808    pub fn build(self) -> PerformanceMarkerInfoINTEL {
37809        self.inner
37810    }
37811}
37812#[repr(C)]
37813#[cfg_attr(feature = "debug", derive(Debug))]
37814#[derive(Copy, Clone)]
37815#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html>"]
37816pub struct PerformanceStreamMarkerInfoINTEL {
37817    pub s_type: StructureType,
37818    pub p_next: *const c_void,
37819    pub marker: u32,
37820}
37821impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL {
37822    fn default() -> Self {
37823        Self {
37824            s_type: StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL,
37825            p_next: ::std::ptr::null(),
37826            marker: u32::default(),
37827        }
37828    }
37829}
37830impl PerformanceStreamMarkerInfoINTEL {
37831    pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
37832        PerformanceStreamMarkerInfoINTELBuilder {
37833            inner: Self::default(),
37834            marker: ::std::marker::PhantomData,
37835        }
37836    }
37837}
37838#[repr(transparent)]
37839pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> {
37840    inner: PerformanceStreamMarkerInfoINTEL,
37841    marker: ::std::marker::PhantomData<&'a ()>,
37842}
37843impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> {
37844    type Target = PerformanceStreamMarkerInfoINTEL;
37845    fn deref(&self) -> &Self::Target {
37846        &self.inner
37847    }
37848}
37849impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> {
37850    fn deref_mut(&mut self) -> &mut Self::Target {
37851        &mut self.inner
37852    }
37853}
37854impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
37855    pub fn marker(mut self, marker: u32) -> Self {
37856        self.inner.marker = marker;
37857        self
37858    }
37859    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37860    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37861    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37862    pub fn build(self) -> PerformanceStreamMarkerInfoINTEL {
37863        self.inner
37864    }
37865}
37866#[repr(C)]
37867#[cfg_attr(feature = "debug", derive(Debug))]
37868#[derive(Copy, Clone)]
37869#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceOverrideInfoINTEL.html>"]
37870pub struct PerformanceOverrideInfoINTEL {
37871    pub s_type: StructureType,
37872    pub p_next: *const c_void,
37873    pub ty: PerformanceOverrideTypeINTEL,
37874    pub enable: Bool32,
37875    pub parameter: u64,
37876}
37877impl ::std::default::Default for PerformanceOverrideInfoINTEL {
37878    fn default() -> Self {
37879        Self {
37880            s_type: StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL,
37881            p_next: ::std::ptr::null(),
37882            ty: PerformanceOverrideTypeINTEL::default(),
37883            enable: Bool32::default(),
37884            parameter: u64::default(),
37885        }
37886    }
37887}
37888impl PerformanceOverrideInfoINTEL {
37889    pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> {
37890        PerformanceOverrideInfoINTELBuilder {
37891            inner: Self::default(),
37892            marker: ::std::marker::PhantomData,
37893        }
37894    }
37895}
37896#[repr(transparent)]
37897pub struct PerformanceOverrideInfoINTELBuilder<'a> {
37898    inner: PerformanceOverrideInfoINTEL,
37899    marker: ::std::marker::PhantomData<&'a ()>,
37900}
37901impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> {
37902    type Target = PerformanceOverrideInfoINTEL;
37903    fn deref(&self) -> &Self::Target {
37904        &self.inner
37905    }
37906}
37907impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> {
37908    fn deref_mut(&mut self) -> &mut Self::Target {
37909        &mut self.inner
37910    }
37911}
37912impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
37913    pub fn ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self {
37914        self.inner.ty = ty;
37915        self
37916    }
37917    pub fn enable(mut self, enable: bool) -> Self {
37918        self.inner.enable = enable.into();
37919        self
37920    }
37921    pub fn parameter(mut self, parameter: u64) -> Self {
37922        self.inner.parameter = parameter;
37923        self
37924    }
37925    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37926    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37927    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37928    pub fn build(self) -> PerformanceOverrideInfoINTEL {
37929        self.inner
37930    }
37931}
37932#[repr(C)]
37933#[cfg_attr(feature = "debug", derive(Debug))]
37934#[derive(Copy, Clone)]
37935#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>"]
37936pub struct PerformanceConfigurationAcquireInfoINTEL {
37937    pub s_type: StructureType,
37938    pub p_next: *const c_void,
37939    pub ty: PerformanceConfigurationTypeINTEL,
37940}
37941impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL {
37942    fn default() -> Self {
37943        Self {
37944            s_type: StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
37945            p_next: ::std::ptr::null(),
37946            ty: PerformanceConfigurationTypeINTEL::default(),
37947        }
37948    }
37949}
37950impl PerformanceConfigurationAcquireInfoINTEL {
37951    pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37952        PerformanceConfigurationAcquireInfoINTELBuilder {
37953            inner: Self::default(),
37954            marker: ::std::marker::PhantomData,
37955        }
37956    }
37957}
37958#[repr(transparent)]
37959pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37960    inner: PerformanceConfigurationAcquireInfoINTEL,
37961    marker: ::std::marker::PhantomData<&'a ()>,
37962}
37963impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37964    type Target = PerformanceConfigurationAcquireInfoINTEL;
37965    fn deref(&self) -> &Self::Target {
37966        &self.inner
37967    }
37968}
37969impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37970    fn deref_mut(&mut self) -> &mut Self::Target {
37971        &mut self.inner
37972    }
37973}
37974impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
37975    pub fn ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self {
37976        self.inner.ty = ty;
37977        self
37978    }
37979    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37980    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37981    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
37982    pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL {
37983        self.inner
37984    }
37985}
37986#[repr(C)]
37987#[cfg_attr(feature = "debug", derive(Debug))]
37988#[derive(Copy, Clone)]
37989#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>"]
37990pub struct PhysicalDeviceShaderClockFeaturesKHR {
37991    pub s_type: StructureType,
37992    pub p_next: *mut c_void,
37993    pub shader_subgroup_clock: Bool32,
37994    pub shader_device_clock: Bool32,
37995}
37996impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR {
37997    fn default() -> Self {
37998        Self {
37999            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
38000            p_next: ::std::ptr::null_mut(),
38001            shader_subgroup_clock: Bool32::default(),
38002            shader_device_clock: Bool32::default(),
38003        }
38004    }
38005}
38006impl PhysicalDeviceShaderClockFeaturesKHR {
38007    pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38008        PhysicalDeviceShaderClockFeaturesKHRBuilder {
38009            inner: Self::default(),
38010            marker: ::std::marker::PhantomData,
38011        }
38012    }
38013}
38014#[repr(transparent)]
38015pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38016    inner: PhysicalDeviceShaderClockFeaturesKHR,
38017    marker: ::std::marker::PhantomData<&'a ()>,
38018}
38019unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
38020unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR {}
38021unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
38022unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {}
38023impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38024    type Target = PhysicalDeviceShaderClockFeaturesKHR;
38025    fn deref(&self) -> &Self::Target {
38026        &self.inner
38027    }
38028}
38029impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38030    fn deref_mut(&mut self) -> &mut Self::Target {
38031        &mut self.inner
38032    }
38033}
38034impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
38035    pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self {
38036        self.inner.shader_subgroup_clock = shader_subgroup_clock.into();
38037        self
38038    }
38039    pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self {
38040        self.inner.shader_device_clock = shader_device_clock.into();
38041        self
38042    }
38043    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38044    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38045    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38046    pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR {
38047        self.inner
38048    }
38049}
38050#[repr(C)]
38051#[cfg_attr(feature = "debug", derive(Debug))]
38052#[derive(Copy, Clone)]
38053#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>"]
38054pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT {
38055    pub s_type: StructureType,
38056    pub p_next: *mut c_void,
38057    pub index_type_uint8: Bool32,
38058}
38059impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT {
38060    fn default() -> Self {
38061        Self {
38062            s_type: StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
38063            p_next: ::std::ptr::null_mut(),
38064            index_type_uint8: Bool32::default(),
38065        }
38066    }
38067}
38068impl PhysicalDeviceIndexTypeUint8FeaturesEXT {
38069    pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38070        PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder {
38071            inner: Self::default(),
38072            marker: ::std::marker::PhantomData,
38073        }
38074    }
38075}
38076#[repr(transparent)]
38077pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38078    inner: PhysicalDeviceIndexTypeUint8FeaturesEXT,
38079    marker: ::std::marker::PhantomData<&'a ()>,
38080}
38081unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
38082unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
38083unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
38084unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
38085impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38086    type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT;
38087    fn deref(&self) -> &Self::Target {
38088        &self.inner
38089    }
38090}
38091impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38092    fn deref_mut(&mut self) -> &mut Self::Target {
38093        &mut self.inner
38094    }
38095}
38096impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
38097    pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self {
38098        self.inner.index_type_uint8 = index_type_uint8.into();
38099        self
38100    }
38101    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38102    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38103    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38104    pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
38105        self.inner
38106    }
38107}
38108#[repr(C)]
38109#[cfg_attr(feature = "debug", derive(Debug))]
38110#[derive(Copy, Clone)]
38111#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>"]
38112pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38113    pub s_type: StructureType,
38114    pub p_next: *mut c_void,
38115    pub shader_sm_count: u32,
38116    pub shader_warps_per_sm: u32,
38117}
38118impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38119    fn default() -> Self {
38120        Self {
38121            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
38122            p_next: ::std::ptr::null_mut(),
38123            shader_sm_count: u32::default(),
38124            shader_warps_per_sm: u32::default(),
38125        }
38126    }
38127}
38128impl PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38129    pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38130        PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder {
38131            inner: Self::default(),
38132            marker: ::std::marker::PhantomData,
38133        }
38134    }
38135}
38136#[repr(transparent)]
38137pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38138    inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV,
38139    marker: ::std::marker::PhantomData<&'a ()>,
38140}
38141unsafe impl ExtendsPhysicalDeviceProperties2
38142    for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_>
38143{
38144}
38145unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {}
38146impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38147    type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
38148    fn deref(&self) -> &Self::Target {
38149        &self.inner
38150    }
38151}
38152impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38153    fn deref_mut(&mut self) -> &mut Self::Target {
38154        &mut self.inner
38155    }
38156}
38157impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
38158    pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self {
38159        self.inner.shader_sm_count = shader_sm_count;
38160        self
38161    }
38162    pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self {
38163        self.inner.shader_warps_per_sm = shader_warps_per_sm;
38164        self
38165    }
38166    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38167    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38168    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38169    pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
38170        self.inner
38171    }
38172}
38173#[repr(C)]
38174#[cfg_attr(feature = "debug", derive(Debug))]
38175#[derive(Copy, Clone)]
38176#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>"]
38177pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38178    pub s_type: StructureType,
38179    pub p_next: *mut c_void,
38180    pub shader_sm_builtins: Bool32,
38181}
38182impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38183    fn default() -> Self {
38184        Self {
38185            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
38186            p_next: ::std::ptr::null_mut(),
38187            shader_sm_builtins: Bool32::default(),
38188        }
38189    }
38190}
38191impl PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38192    pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38193        PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder {
38194            inner: Self::default(),
38195            marker: ::std::marker::PhantomData,
38196        }
38197    }
38198}
38199#[repr(transparent)]
38200pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38201    inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV,
38202    marker: ::std::marker::PhantomData<&'a ()>,
38203}
38204unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
38205unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
38206unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
38207unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
38208impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38209    type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
38210    fn deref(&self) -> &Self::Target {
38211        &self.inner
38212    }
38213}
38214impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38215    fn deref_mut(&mut self) -> &mut Self::Target {
38216        &mut self.inner
38217    }
38218}
38219impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
38220    pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self {
38221        self.inner.shader_sm_builtins = shader_sm_builtins.into();
38222        self
38223    }
38224    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38225    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38226    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38227    pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
38228        self.inner
38229    }
38230}
38231#[repr(C)]
38232#[cfg_attr(feature = "debug", derive(Debug))]
38233#[derive(Copy, Clone)]
38234#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>"]
38235pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38236    pub s_type: StructureType,
38237    pub p_next: *mut c_void,
38238    pub fragment_shader_sample_interlock: Bool32,
38239    pub fragment_shader_pixel_interlock: Bool32,
38240    pub fragment_shader_shading_rate_interlock: Bool32,
38241}
38242impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38243    fn default() -> Self {
38244        Self {
38245            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
38246            p_next: ::std::ptr::null_mut(),
38247            fragment_shader_sample_interlock: Bool32::default(),
38248            fragment_shader_pixel_interlock: Bool32::default(),
38249            fragment_shader_shading_rate_interlock: Bool32::default(),
38250        }
38251    }
38252}
38253impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38254    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38255        PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder {
38256            inner: Self::default(),
38257            marker: ::std::marker::PhantomData,
38258        }
38259    }
38260}
38261#[repr(transparent)]
38262pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38263    inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
38264    marker: ::std::marker::PhantomData<&'a ()>,
38265}
38266unsafe impl ExtendsPhysicalDeviceFeatures2
38267    for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
38268{
38269}
38270unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
38271unsafe impl ExtendsDeviceCreateInfo
38272    for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
38273{
38274}
38275unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
38276impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38277    type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
38278    fn deref(&self) -> &Self::Target {
38279        &self.inner
38280    }
38281}
38282impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38283    fn deref_mut(&mut self) -> &mut Self::Target {
38284        &mut self.inner
38285    }
38286}
38287impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
38288    pub fn fragment_shader_sample_interlock(
38289        mut self,
38290        fragment_shader_sample_interlock: bool,
38291    ) -> Self {
38292        self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into();
38293        self
38294    }
38295    pub fn fragment_shader_pixel_interlock(
38296        mut self,
38297        fragment_shader_pixel_interlock: bool,
38298    ) -> Self {
38299        self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into();
38300        self
38301    }
38302    pub fn fragment_shader_shading_rate_interlock(
38303        mut self,
38304        fragment_shader_shading_rate_interlock: bool,
38305    ) -> Self {
38306        self.inner.fragment_shader_shading_rate_interlock =
38307            fragment_shader_shading_rate_interlock.into();
38308        self
38309    }
38310    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38311    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38312    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38313    pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
38314        self.inner
38315    }
38316}
38317#[repr(C)]
38318#[cfg_attr(feature = "debug", derive(Debug))]
38319#[derive(Copy, Clone)]
38320#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>"]
38321pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38322    pub s_type: StructureType,
38323    pub p_next: *mut c_void,
38324    pub separate_depth_stencil_layouts: Bool32,
38325}
38326impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38327    fn default() -> Self {
38328        Self {
38329            s_type: StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
38330            p_next: ::std::ptr::null_mut(),
38331            separate_depth_stencil_layouts: Bool32::default(),
38332        }
38333    }
38334}
38335impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38336    pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38337        PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder {
38338            inner: Self::default(),
38339            marker: ::std::marker::PhantomData,
38340        }
38341    }
38342}
38343#[repr(transparent)]
38344pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38345    inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
38346    marker: ::std::marker::PhantomData<&'a ()>,
38347}
38348unsafe impl ExtendsPhysicalDeviceFeatures2
38349    for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
38350{
38351}
38352unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
38353unsafe impl ExtendsDeviceCreateInfo
38354    for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
38355{
38356}
38357unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
38358impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38359    type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
38360    fn deref(&self) -> &Self::Target {
38361        &self.inner
38362    }
38363}
38364impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38365    fn deref_mut(&mut self) -> &mut Self::Target {
38366        &mut self.inner
38367    }
38368}
38369impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
38370    pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
38371        self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
38372        self
38373    }
38374    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38375    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38376    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38377    pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
38378        self.inner
38379    }
38380}
38381#[repr(C)]
38382#[cfg_attr(feature = "debug", derive(Debug))]
38383#[derive(Copy, Clone)]
38384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReferenceStencilLayout.html>"]
38385pub struct AttachmentReferenceStencilLayout {
38386    pub s_type: StructureType,
38387    pub p_next: *mut c_void,
38388    pub stencil_layout: ImageLayout,
38389}
38390impl ::std::default::Default for AttachmentReferenceStencilLayout {
38391    fn default() -> Self {
38392        Self {
38393            s_type: StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
38394            p_next: ::std::ptr::null_mut(),
38395            stencil_layout: ImageLayout::default(),
38396        }
38397    }
38398}
38399impl AttachmentReferenceStencilLayout {
38400    pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> {
38401        AttachmentReferenceStencilLayoutBuilder {
38402            inner: Self::default(),
38403            marker: ::std::marker::PhantomData,
38404        }
38405    }
38406}
38407#[repr(transparent)]
38408pub struct AttachmentReferenceStencilLayoutBuilder<'a> {
38409    inner: AttachmentReferenceStencilLayout,
38410    marker: ::std::marker::PhantomData<&'a ()>,
38411}
38412unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {}
38413unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {}
38414impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> {
38415    type Target = AttachmentReferenceStencilLayout;
38416    fn deref(&self) -> &Self::Target {
38417        &self.inner
38418    }
38419}
38420impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> {
38421    fn deref_mut(&mut self) -> &mut Self::Target {
38422        &mut self.inner
38423    }
38424}
38425impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
38426    pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self {
38427        self.inner.stencil_layout = stencil_layout;
38428        self
38429    }
38430    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38431    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38432    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38433    pub fn build(self) -> AttachmentReferenceStencilLayout {
38434        self.inner
38435    }
38436}
38437#[repr(C)]
38438#[cfg_attr(feature = "debug", derive(Debug))]
38439#[derive(Copy, Clone)]
38440#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html>"]
38441pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38442    pub s_type: StructureType,
38443    pub p_next: *mut c_void,
38444    pub primitive_topology_list_restart: Bool32,
38445    pub primitive_topology_patch_list_restart: Bool32,
38446}
38447impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38448    fn default() -> Self {
38449        Self {
38450            s_type: StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT,
38451            p_next: ::std::ptr::null_mut(),
38452            primitive_topology_list_restart: Bool32::default(),
38453            primitive_topology_patch_list_restart: Bool32::default(),
38454        }
38455    }
38456}
38457impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38458    pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38459        PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder {
38460            inner: Self::default(),
38461            marker: ::std::marker::PhantomData,
38462        }
38463    }
38464}
38465#[repr(transparent)]
38466pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38467    inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT,
38468    marker: ::std::marker::PhantomData<&'a ()>,
38469}
38470unsafe impl ExtendsPhysicalDeviceFeatures2
38471    for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_>
38472{
38473}
38474unsafe impl ExtendsPhysicalDeviceFeatures2
38475    for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
38476{
38477}
38478unsafe impl ExtendsDeviceCreateInfo
38479    for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_>
38480{
38481}
38482unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {}
38483impl<'a> ::std::ops::Deref for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38484    type Target = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
38485    fn deref(&self) -> &Self::Target {
38486        &self.inner
38487    }
38488}
38489impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38490    fn deref_mut(&mut self) -> &mut Self::Target {
38491        &mut self.inner
38492    }
38493}
38494impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
38495    pub fn primitive_topology_list_restart(
38496        mut self,
38497        primitive_topology_list_restart: bool,
38498    ) -> Self {
38499        self.inner.primitive_topology_list_restart = primitive_topology_list_restart.into();
38500        self
38501    }
38502    pub fn primitive_topology_patch_list_restart(
38503        mut self,
38504        primitive_topology_patch_list_restart: bool,
38505    ) -> Self {
38506        self.inner.primitive_topology_patch_list_restart =
38507            primitive_topology_patch_list_restart.into();
38508        self
38509    }
38510    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38511    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38512    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38513    pub fn build(self) -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
38514        self.inner
38515    }
38516}
38517#[repr(C)]
38518#[cfg_attr(feature = "debug", derive(Debug))]
38519#[derive(Copy, Clone)]
38520#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionStencilLayout.html>"]
38521pub struct AttachmentDescriptionStencilLayout {
38522    pub s_type: StructureType,
38523    pub p_next: *mut c_void,
38524    pub stencil_initial_layout: ImageLayout,
38525    pub stencil_final_layout: ImageLayout,
38526}
38527impl ::std::default::Default for AttachmentDescriptionStencilLayout {
38528    fn default() -> Self {
38529        Self {
38530            s_type: StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
38531            p_next: ::std::ptr::null_mut(),
38532            stencil_initial_layout: ImageLayout::default(),
38533            stencil_final_layout: ImageLayout::default(),
38534        }
38535    }
38536}
38537impl AttachmentDescriptionStencilLayout {
38538    pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> {
38539        AttachmentDescriptionStencilLayoutBuilder {
38540            inner: Self::default(),
38541            marker: ::std::marker::PhantomData,
38542        }
38543    }
38544}
38545#[repr(transparent)]
38546pub struct AttachmentDescriptionStencilLayoutBuilder<'a> {
38547    inner: AttachmentDescriptionStencilLayout,
38548    marker: ::std::marker::PhantomData<&'a ()>,
38549}
38550unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {}
38551unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {}
38552impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> {
38553    type Target = AttachmentDescriptionStencilLayout;
38554    fn deref(&self) -> &Self::Target {
38555        &self.inner
38556    }
38557}
38558impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> {
38559    fn deref_mut(&mut self) -> &mut Self::Target {
38560        &mut self.inner
38561    }
38562}
38563impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
38564    pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self {
38565        self.inner.stencil_initial_layout = stencil_initial_layout;
38566        self
38567    }
38568    pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self {
38569        self.inner.stencil_final_layout = stencil_final_layout;
38570        self
38571    }
38572    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38573    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38574    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38575    pub fn build(self) -> AttachmentDescriptionStencilLayout {
38576        self.inner
38577    }
38578}
38579#[repr(C)]
38580#[cfg_attr(feature = "debug", derive(Debug))]
38581#[derive(Copy, Clone)]
38582#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>"]
38583pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38584    pub s_type: StructureType,
38585    pub p_next: *mut c_void,
38586    pub pipeline_executable_info: Bool32,
38587}
38588impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38589    fn default() -> Self {
38590        Self {
38591            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
38592            p_next: ::std::ptr::null_mut(),
38593            pipeline_executable_info: Bool32::default(),
38594        }
38595    }
38596}
38597impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38598    pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38599        PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder {
38600            inner: Self::default(),
38601            marker: ::std::marker::PhantomData,
38602        }
38603    }
38604}
38605#[repr(transparent)]
38606pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38607    inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
38608    marker: ::std::marker::PhantomData<&'a ()>,
38609}
38610unsafe impl ExtendsPhysicalDeviceFeatures2
38611    for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
38612{
38613}
38614unsafe impl ExtendsPhysicalDeviceFeatures2
38615    for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
38616{
38617}
38618unsafe impl ExtendsDeviceCreateInfo
38619    for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
38620{
38621}
38622unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {}
38623impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38624    type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
38625    fn deref(&self) -> &Self::Target {
38626        &self.inner
38627    }
38628}
38629impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38630    fn deref_mut(&mut self) -> &mut Self::Target {
38631        &mut self.inner
38632    }
38633}
38634impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
38635    pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self {
38636        self.inner.pipeline_executable_info = pipeline_executable_info.into();
38637        self
38638    }
38639    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38640    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38641    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38642    pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
38643        self.inner
38644    }
38645}
38646#[repr(C)]
38647#[cfg_attr(feature = "debug", derive(Debug))]
38648#[derive(Copy, Clone)]
38649#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInfoKHR.html>"]
38650pub struct PipelineInfoKHR {
38651    pub s_type: StructureType,
38652    pub p_next: *const c_void,
38653    pub pipeline: Pipeline,
38654}
38655impl ::std::default::Default for PipelineInfoKHR {
38656    fn default() -> Self {
38657        Self {
38658            s_type: StructureType::PIPELINE_INFO_KHR,
38659            p_next: ::std::ptr::null(),
38660            pipeline: Pipeline::default(),
38661        }
38662    }
38663}
38664impl PipelineInfoKHR {
38665    pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> {
38666        PipelineInfoKHRBuilder {
38667            inner: Self::default(),
38668            marker: ::std::marker::PhantomData,
38669        }
38670    }
38671}
38672#[repr(transparent)]
38673pub struct PipelineInfoKHRBuilder<'a> {
38674    inner: PipelineInfoKHR,
38675    marker: ::std::marker::PhantomData<&'a ()>,
38676}
38677impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> {
38678    type Target = PipelineInfoKHR;
38679    fn deref(&self) -> &Self::Target {
38680        &self.inner
38681    }
38682}
38683impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> {
38684    fn deref_mut(&mut self) -> &mut Self::Target {
38685        &mut self.inner
38686    }
38687}
38688impl<'a> PipelineInfoKHRBuilder<'a> {
38689    pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
38690        self.inner.pipeline = pipeline;
38691        self
38692    }
38693    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38694    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38695    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38696    pub fn build(self) -> PipelineInfoKHR {
38697        self.inner
38698    }
38699}
38700#[repr(C)]
38701#[derive(Copy, Clone)]
38702#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutablePropertiesKHR.html>"]
38703pub struct PipelineExecutablePropertiesKHR {
38704    pub s_type: StructureType,
38705    pub p_next: *mut c_void,
38706    pub stages: ShaderStageFlags,
38707    pub name: [c_char; MAX_DESCRIPTION_SIZE],
38708    pub description: [c_char; MAX_DESCRIPTION_SIZE],
38709    pub subgroup_size: u32,
38710}
38711#[cfg(feature = "debug")]
38712impl fmt::Debug for PipelineExecutablePropertiesKHR {
38713    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
38714        fmt.debug_struct("PipelineExecutablePropertiesKHR")
38715            .field("s_type", &self.s_type)
38716            .field("p_next", &self.p_next)
38717            .field("stages", &self.stages)
38718            .field("name", &unsafe {
38719                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
38720            })
38721            .field("description", &unsafe {
38722                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
38723            })
38724            .field("subgroup_size", &self.subgroup_size)
38725            .finish()
38726    }
38727}
38728impl ::std::default::Default for PipelineExecutablePropertiesKHR {
38729    fn default() -> Self {
38730        Self {
38731            s_type: StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR,
38732            p_next: ::std::ptr::null_mut(),
38733            stages: ShaderStageFlags::default(),
38734            name: unsafe { ::std::mem::zeroed() },
38735            description: unsafe { ::std::mem::zeroed() },
38736            subgroup_size: u32::default(),
38737        }
38738    }
38739}
38740impl PipelineExecutablePropertiesKHR {
38741    pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> {
38742        PipelineExecutablePropertiesKHRBuilder {
38743            inner: Self::default(),
38744            marker: ::std::marker::PhantomData,
38745        }
38746    }
38747}
38748#[repr(transparent)]
38749pub struct PipelineExecutablePropertiesKHRBuilder<'a> {
38750    inner: PipelineExecutablePropertiesKHR,
38751    marker: ::std::marker::PhantomData<&'a ()>,
38752}
38753impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> {
38754    type Target = PipelineExecutablePropertiesKHR;
38755    fn deref(&self) -> &Self::Target {
38756        &self.inner
38757    }
38758}
38759impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> {
38760    fn deref_mut(&mut self) -> &mut Self::Target {
38761        &mut self.inner
38762    }
38763}
38764impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
38765    pub fn stages(mut self, stages: ShaderStageFlags) -> Self {
38766        self.inner.stages = stages;
38767        self
38768    }
38769    pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38770        self.inner.name = name;
38771        self
38772    }
38773    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38774        self.inner.description = description;
38775        self
38776    }
38777    pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
38778        self.inner.subgroup_size = subgroup_size;
38779        self
38780    }
38781    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38782    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38783    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38784    pub fn build(self) -> PipelineExecutablePropertiesKHR {
38785        self.inner
38786    }
38787}
38788#[repr(C)]
38789#[cfg_attr(feature = "debug", derive(Debug))]
38790#[derive(Copy, Clone)]
38791#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInfoKHR.html>"]
38792pub struct PipelineExecutableInfoKHR {
38793    pub s_type: StructureType,
38794    pub p_next: *const c_void,
38795    pub pipeline: Pipeline,
38796    pub executable_index: u32,
38797}
38798impl ::std::default::Default for PipelineExecutableInfoKHR {
38799    fn default() -> Self {
38800        Self {
38801            s_type: StructureType::PIPELINE_EXECUTABLE_INFO_KHR,
38802            p_next: ::std::ptr::null(),
38803            pipeline: Pipeline::default(),
38804            executable_index: u32::default(),
38805        }
38806    }
38807}
38808impl PipelineExecutableInfoKHR {
38809    pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> {
38810        PipelineExecutableInfoKHRBuilder {
38811            inner: Self::default(),
38812            marker: ::std::marker::PhantomData,
38813        }
38814    }
38815}
38816#[repr(transparent)]
38817pub struct PipelineExecutableInfoKHRBuilder<'a> {
38818    inner: PipelineExecutableInfoKHR,
38819    marker: ::std::marker::PhantomData<&'a ()>,
38820}
38821impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> {
38822    type Target = PipelineExecutableInfoKHR;
38823    fn deref(&self) -> &Self::Target {
38824        &self.inner
38825    }
38826}
38827impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> {
38828    fn deref_mut(&mut self) -> &mut Self::Target {
38829        &mut self.inner
38830    }
38831}
38832impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
38833    pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
38834        self.inner.pipeline = pipeline;
38835        self
38836    }
38837    pub fn executable_index(mut self, executable_index: u32) -> Self {
38838        self.inner.executable_index = executable_index;
38839        self
38840    }
38841    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38842    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38843    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38844    pub fn build(self) -> PipelineExecutableInfoKHR {
38845        self.inner
38846    }
38847}
38848#[repr(C)]
38849#[derive(Copy, Clone)]
38850#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html>"]
38851pub union PipelineExecutableStatisticValueKHR {
38852    pub b32: Bool32,
38853    pub i64: i64,
38854    pub u64: u64,
38855    pub f64: f64,
38856}
38857impl ::std::default::Default for PipelineExecutableStatisticValueKHR {
38858    fn default() -> Self {
38859        unsafe { ::std::mem::zeroed() }
38860    }
38861}
38862#[repr(C)]
38863#[derive(Copy, Clone)]
38864#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticKHR.html>"]
38865pub struct PipelineExecutableStatisticKHR {
38866    pub s_type: StructureType,
38867    pub p_next: *mut c_void,
38868    pub name: [c_char; MAX_DESCRIPTION_SIZE],
38869    pub description: [c_char; MAX_DESCRIPTION_SIZE],
38870    pub format: PipelineExecutableStatisticFormatKHR,
38871    pub value: PipelineExecutableStatisticValueKHR,
38872}
38873#[cfg(feature = "debug")]
38874impl fmt::Debug for PipelineExecutableStatisticKHR {
38875    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
38876        fmt.debug_struct("PipelineExecutableStatisticKHR")
38877            .field("s_type", &self.s_type)
38878            .field("p_next", &self.p_next)
38879            .field("name", &unsafe {
38880                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
38881            })
38882            .field("description", &unsafe {
38883                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
38884            })
38885            .field("format", &self.format)
38886            .field("value", &"union")
38887            .finish()
38888    }
38889}
38890impl ::std::default::Default for PipelineExecutableStatisticKHR {
38891    fn default() -> Self {
38892        Self {
38893            s_type: StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR,
38894            p_next: ::std::ptr::null_mut(),
38895            name: unsafe { ::std::mem::zeroed() },
38896            description: unsafe { ::std::mem::zeroed() },
38897            format: PipelineExecutableStatisticFormatKHR::default(),
38898            value: PipelineExecutableStatisticValueKHR::default(),
38899        }
38900    }
38901}
38902impl PipelineExecutableStatisticKHR {
38903    pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> {
38904        PipelineExecutableStatisticKHRBuilder {
38905            inner: Self::default(),
38906            marker: ::std::marker::PhantomData,
38907        }
38908    }
38909}
38910#[repr(transparent)]
38911pub struct PipelineExecutableStatisticKHRBuilder<'a> {
38912    inner: PipelineExecutableStatisticKHR,
38913    marker: ::std::marker::PhantomData<&'a ()>,
38914}
38915impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> {
38916    type Target = PipelineExecutableStatisticKHR;
38917    fn deref(&self) -> &Self::Target {
38918        &self.inner
38919    }
38920}
38921impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> {
38922    fn deref_mut(&mut self) -> &mut Self::Target {
38923        &mut self.inner
38924    }
38925}
38926impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
38927    pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38928        self.inner.name = name;
38929        self
38930    }
38931    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
38932        self.inner.description = description;
38933        self
38934    }
38935    pub fn format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self {
38936        self.inner.format = format;
38937        self
38938    }
38939    pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self {
38940        self.inner.value = value;
38941        self
38942    }
38943    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38944    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38945    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
38946    pub fn build(self) -> PipelineExecutableStatisticKHR {
38947        self.inner
38948    }
38949}
38950#[repr(C)]
38951#[derive(Copy, Clone)]
38952#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html>"]
38953pub struct PipelineExecutableInternalRepresentationKHR {
38954    pub s_type: StructureType,
38955    pub p_next: *mut c_void,
38956    pub name: [c_char; MAX_DESCRIPTION_SIZE],
38957    pub description: [c_char; MAX_DESCRIPTION_SIZE],
38958    pub is_text: Bool32,
38959    pub data_size: usize,
38960    pub p_data: *mut c_void,
38961}
38962#[cfg(feature = "debug")]
38963impl fmt::Debug for PipelineExecutableInternalRepresentationKHR {
38964    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
38965        fmt.debug_struct("PipelineExecutableInternalRepresentationKHR")
38966            .field("s_type", &self.s_type)
38967            .field("p_next", &self.p_next)
38968            .field("name", &unsafe {
38969                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
38970            })
38971            .field("description", &unsafe {
38972                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
38973            })
38974            .field("is_text", &self.is_text)
38975            .field("data_size", &self.data_size)
38976            .field("p_data", &self.p_data)
38977            .finish()
38978    }
38979}
38980impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR {
38981    fn default() -> Self {
38982        Self {
38983            s_type: StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
38984            p_next: ::std::ptr::null_mut(),
38985            name: unsafe { ::std::mem::zeroed() },
38986            description: unsafe { ::std::mem::zeroed() },
38987            is_text: Bool32::default(),
38988            data_size: usize::default(),
38989            p_data: ::std::ptr::null_mut(),
38990        }
38991    }
38992}
38993impl PipelineExecutableInternalRepresentationKHR {
38994    pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
38995        PipelineExecutableInternalRepresentationKHRBuilder {
38996            inner: Self::default(),
38997            marker: ::std::marker::PhantomData,
38998        }
38999    }
39000}
39001#[repr(transparent)]
39002pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39003    inner: PipelineExecutableInternalRepresentationKHR,
39004    marker: ::std::marker::PhantomData<&'a ()>,
39005}
39006impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39007    type Target = PipelineExecutableInternalRepresentationKHR;
39008    fn deref(&self) -> &Self::Target {
39009        &self.inner
39010    }
39011}
39012impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39013    fn deref_mut(&mut self) -> &mut Self::Target {
39014        &mut self.inner
39015    }
39016}
39017impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
39018    pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
39019        self.inner.name = name;
39020        self
39021    }
39022    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
39023        self.inner.description = description;
39024        self
39025    }
39026    pub fn is_text(mut self, is_text: bool) -> Self {
39027        self.inner.is_text = is_text.into();
39028        self
39029    }
39030    pub fn data(mut self, data: &'a mut [u8]) -> Self {
39031        self.inner.data_size = data.len();
39032        self.inner.p_data = data.as_mut_ptr() as *mut c_void;
39033        self
39034    }
39035    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39036    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39037    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39038    pub fn build(self) -> PipelineExecutableInternalRepresentationKHR {
39039        self.inner
39040    }
39041}
39042#[repr(C)]
39043#[cfg_attr(feature = "debug", derive(Debug))]
39044#[derive(Copy, Clone)]
39045#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.html>"]
39046pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39047    pub s_type: StructureType,
39048    pub p_next: *mut c_void,
39049    pub shader_demote_to_helper_invocation: Bool32,
39050}
39051impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39052    fn default() -> Self {
39053        Self {
39054            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
39055            p_next: ::std::ptr::null_mut(),
39056            shader_demote_to_helper_invocation: Bool32::default(),
39057        }
39058    }
39059}
39060impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39061    pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39062        PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder {
39063            inner: Self::default(),
39064            marker: ::std::marker::PhantomData,
39065        }
39066    }
39067}
39068#[repr(transparent)]
39069pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39070    inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures,
39071    marker: ::std::marker::PhantomData<&'a ()>,
39072}
39073unsafe impl ExtendsPhysicalDeviceFeatures2
39074    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
39075{
39076}
39077unsafe impl ExtendsPhysicalDeviceFeatures2
39078    for PhysicalDeviceShaderDemoteToHelperInvocationFeatures
39079{
39080}
39081unsafe impl ExtendsDeviceCreateInfo
39082    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
39083{
39084}
39085unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {}
39086impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39087    type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
39088    fn deref(&self) -> &Self::Target {
39089        &self.inner
39090    }
39091}
39092impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39093    fn deref_mut(&mut self) -> &mut Self::Target {
39094        &mut self.inner
39095    }
39096}
39097impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
39098    pub fn shader_demote_to_helper_invocation(
39099        mut self,
39100        shader_demote_to_helper_invocation: bool,
39101    ) -> Self {
39102        self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
39103        self
39104    }
39105    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39106    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39107    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39108    pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
39109        self.inner
39110    }
39111}
39112#[repr(C)]
39113#[cfg_attr(feature = "debug", derive(Debug))]
39114#[derive(Copy, Clone)]
39115#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>"]
39116pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39117    pub s_type: StructureType,
39118    pub p_next: *mut c_void,
39119    pub texel_buffer_alignment: Bool32,
39120}
39121impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39122    fn default() -> Self {
39123        Self {
39124            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
39125            p_next: ::std::ptr::null_mut(),
39126            texel_buffer_alignment: Bool32::default(),
39127        }
39128    }
39129}
39130impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39131    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39132        PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder {
39133            inner: Self::default(),
39134            marker: ::std::marker::PhantomData,
39135        }
39136    }
39137}
39138#[repr(transparent)]
39139pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39140    inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
39141    marker: ::std::marker::PhantomData<&'a ()>,
39142}
39143unsafe impl ExtendsPhysicalDeviceFeatures2
39144    for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_>
39145{
39146}
39147unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
39148unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {}
39149unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
39150impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39151    type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
39152    fn deref(&self) -> &Self::Target {
39153        &self.inner
39154    }
39155}
39156impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39157    fn deref_mut(&mut self) -> &mut Self::Target {
39158        &mut self.inner
39159    }
39160}
39161impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
39162    pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self {
39163        self.inner.texel_buffer_alignment = texel_buffer_alignment.into();
39164        self
39165    }
39166    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39167    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39168    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39169    pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
39170        self.inner
39171    }
39172}
39173#[repr(C)]
39174#[cfg_attr(feature = "debug", derive(Debug))]
39175#[derive(Copy, Clone)]
39176#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentProperties.html>"]
39177pub struct PhysicalDeviceTexelBufferAlignmentProperties {
39178    pub s_type: StructureType,
39179    pub p_next: *mut c_void,
39180    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
39181    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
39182    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
39183    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
39184}
39185impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties {
39186    fn default() -> Self {
39187        Self {
39188            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES,
39189            p_next: ::std::ptr::null_mut(),
39190            storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
39191            storage_texel_buffer_offset_single_texel_alignment: Bool32::default(),
39192            uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
39193            uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(),
39194        }
39195    }
39196}
39197impl PhysicalDeviceTexelBufferAlignmentProperties {
39198    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39199        PhysicalDeviceTexelBufferAlignmentPropertiesBuilder {
39200            inner: Self::default(),
39201            marker: ::std::marker::PhantomData,
39202        }
39203    }
39204}
39205#[repr(transparent)]
39206pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39207    inner: PhysicalDeviceTexelBufferAlignmentProperties,
39208    marker: ::std::marker::PhantomData<&'a ()>,
39209}
39210unsafe impl ExtendsPhysicalDeviceProperties2
39211    for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'_>
39212{
39213}
39214unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties {}
39215impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39216    type Target = PhysicalDeviceTexelBufferAlignmentProperties;
39217    fn deref(&self) -> &Self::Target {
39218        &self.inner
39219    }
39220}
39221impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39222    fn deref_mut(&mut self) -> &mut Self::Target {
39223        &mut self.inner
39224    }
39225}
39226impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
39227    pub fn storage_texel_buffer_offset_alignment_bytes(
39228        mut self,
39229        storage_texel_buffer_offset_alignment_bytes: DeviceSize,
39230    ) -> Self {
39231        self.inner.storage_texel_buffer_offset_alignment_bytes =
39232            storage_texel_buffer_offset_alignment_bytes;
39233        self
39234    }
39235    pub fn storage_texel_buffer_offset_single_texel_alignment(
39236        mut self,
39237        storage_texel_buffer_offset_single_texel_alignment: bool,
39238    ) -> Self {
39239        self.inner
39240            .storage_texel_buffer_offset_single_texel_alignment =
39241            storage_texel_buffer_offset_single_texel_alignment.into();
39242        self
39243    }
39244    pub fn uniform_texel_buffer_offset_alignment_bytes(
39245        mut self,
39246        uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
39247    ) -> Self {
39248        self.inner.uniform_texel_buffer_offset_alignment_bytes =
39249            uniform_texel_buffer_offset_alignment_bytes;
39250        self
39251    }
39252    pub fn uniform_texel_buffer_offset_single_texel_alignment(
39253        mut self,
39254        uniform_texel_buffer_offset_single_texel_alignment: bool,
39255    ) -> Self {
39256        self.inner
39257            .uniform_texel_buffer_offset_single_texel_alignment =
39258            uniform_texel_buffer_offset_single_texel_alignment.into();
39259        self
39260    }
39261    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39262    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39263    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39264    pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentProperties {
39265        self.inner
39266    }
39267}
39268#[repr(C)]
39269#[cfg_attr(feature = "debug", derive(Debug))]
39270#[derive(Copy, Clone)]
39271#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeatures.html>"]
39272pub struct PhysicalDeviceSubgroupSizeControlFeatures {
39273    pub s_type: StructureType,
39274    pub p_next: *mut c_void,
39275    pub subgroup_size_control: Bool32,
39276    pub compute_full_subgroups: Bool32,
39277}
39278impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures {
39279    fn default() -> Self {
39280        Self {
39281            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES,
39282            p_next: ::std::ptr::null_mut(),
39283            subgroup_size_control: Bool32::default(),
39284            compute_full_subgroups: Bool32::default(),
39285        }
39286    }
39287}
39288impl PhysicalDeviceSubgroupSizeControlFeatures {
39289    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39290        PhysicalDeviceSubgroupSizeControlFeaturesBuilder {
39291            inner: Self::default(),
39292            marker: ::std::marker::PhantomData,
39293        }
39294    }
39295}
39296#[repr(transparent)]
39297pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39298    inner: PhysicalDeviceSubgroupSizeControlFeatures,
39299    marker: ::std::marker::PhantomData<&'a ()>,
39300}
39301unsafe impl ExtendsPhysicalDeviceFeatures2
39302    for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_>
39303{
39304}
39305unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures {}
39306unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> {}
39307unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures {}
39308impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39309    type Target = PhysicalDeviceSubgroupSizeControlFeatures;
39310    fn deref(&self) -> &Self::Target {
39311        &self.inner
39312    }
39313}
39314impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39315    fn deref_mut(&mut self) -> &mut Self::Target {
39316        &mut self.inner
39317    }
39318}
39319impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
39320    pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
39321        self.inner.subgroup_size_control = subgroup_size_control.into();
39322        self
39323    }
39324    pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
39325        self.inner.compute_full_subgroups = compute_full_subgroups.into();
39326        self
39327    }
39328    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39329    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39330    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39331    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeatures {
39332        self.inner
39333    }
39334}
39335#[repr(C)]
39336#[cfg_attr(feature = "debug", derive(Debug))]
39337#[derive(Copy, Clone)]
39338#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlProperties.html>"]
39339pub struct PhysicalDeviceSubgroupSizeControlProperties {
39340    pub s_type: StructureType,
39341    pub p_next: *mut c_void,
39342    pub min_subgroup_size: u32,
39343    pub max_subgroup_size: u32,
39344    pub max_compute_workgroup_subgroups: u32,
39345    pub required_subgroup_size_stages: ShaderStageFlags,
39346}
39347impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties {
39348    fn default() -> Self {
39349        Self {
39350            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES,
39351            p_next: ::std::ptr::null_mut(),
39352            min_subgroup_size: u32::default(),
39353            max_subgroup_size: u32::default(),
39354            max_compute_workgroup_subgroups: u32::default(),
39355            required_subgroup_size_stages: ShaderStageFlags::default(),
39356        }
39357    }
39358}
39359impl PhysicalDeviceSubgroupSizeControlProperties {
39360    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39361        PhysicalDeviceSubgroupSizeControlPropertiesBuilder {
39362            inner: Self::default(),
39363            marker: ::std::marker::PhantomData,
39364        }
39365    }
39366}
39367#[repr(transparent)]
39368pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39369    inner: PhysicalDeviceSubgroupSizeControlProperties,
39370    marker: ::std::marker::PhantomData<&'a ()>,
39371}
39372unsafe impl ExtendsPhysicalDeviceProperties2
39373    for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'_>
39374{
39375}
39376unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties {}
39377impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39378    type Target = PhysicalDeviceSubgroupSizeControlProperties;
39379    fn deref(&self) -> &Self::Target {
39380        &self.inner
39381    }
39382}
39383impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39384    fn deref_mut(&mut self) -> &mut Self::Target {
39385        &mut self.inner
39386    }
39387}
39388impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
39389    pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
39390        self.inner.min_subgroup_size = min_subgroup_size;
39391        self
39392    }
39393    pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
39394        self.inner.max_subgroup_size = max_subgroup_size;
39395        self
39396    }
39397    pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
39398        self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
39399        self
39400    }
39401    pub fn required_subgroup_size_stages(
39402        mut self,
39403        required_subgroup_size_stages: ShaderStageFlags,
39404    ) -> Self {
39405        self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
39406        self
39407    }
39408    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39409    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39410    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39411    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlProperties {
39412        self.inner
39413    }
39414}
39415#[repr(C)]
39416#[cfg_attr(feature = "debug", derive(Debug))]
39417#[derive(Copy, Clone)]
39418#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.html>"]
39419pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39420    pub s_type: StructureType,
39421    pub p_next: *mut c_void,
39422    pub required_subgroup_size: u32,
39423}
39424impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39425    fn default() -> Self {
39426        Self {
39427            s_type: StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,
39428            p_next: ::std::ptr::null_mut(),
39429            required_subgroup_size: u32::default(),
39430        }
39431    }
39432}
39433impl PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39434    pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39435        PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder {
39436            inner: Self::default(),
39437            marker: ::std::marker::PhantomData,
39438        }
39439    }
39440}
39441#[repr(transparent)]
39442pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39443    inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo,
39444    marker: ::std::marker::PhantomData<&'a ()>,
39445}
39446unsafe impl ExtendsPipelineShaderStageCreateInfo
39447    for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_>
39448{
39449}
39450unsafe impl ExtendsPipelineShaderStageCreateInfo
39451    for PipelineShaderStageRequiredSubgroupSizeCreateInfo
39452{
39453}
39454impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39455    type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
39456    fn deref(&self) -> &Self::Target {
39457        &self.inner
39458    }
39459}
39460impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39461    fn deref_mut(&mut self) -> &mut Self::Target {
39462        &mut self.inner
39463    }
39464}
39465impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
39466    pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self {
39467        self.inner.required_subgroup_size = required_subgroup_size;
39468        self
39469    }
39470    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39471    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39472    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39473    pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo {
39474        self.inner
39475    }
39476}
39477#[repr(C)]
39478#[cfg_attr(feature = "debug", derive(Debug))]
39479#[derive(Copy, Clone)]
39480#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html>"]
39481pub struct SubpassShadingPipelineCreateInfoHUAWEI {
39482    pub s_type: StructureType,
39483    pub p_next: *mut c_void,
39484    pub render_pass: RenderPass,
39485    pub subpass: u32,
39486}
39487impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI {
39488    fn default() -> Self {
39489        Self {
39490            s_type: StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI,
39491            p_next: ::std::ptr::null_mut(),
39492            render_pass: RenderPass::default(),
39493            subpass: u32::default(),
39494        }
39495    }
39496}
39497impl SubpassShadingPipelineCreateInfoHUAWEI {
39498    pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39499        SubpassShadingPipelineCreateInfoHUAWEIBuilder {
39500            inner: Self::default(),
39501            marker: ::std::marker::PhantomData,
39502        }
39503    }
39504}
39505#[repr(transparent)]
39506pub struct SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39507    inner: SubpassShadingPipelineCreateInfoHUAWEI,
39508    marker: ::std::marker::PhantomData<&'a ()>,
39509}
39510unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'_> {}
39511unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI {}
39512impl<'a> ::std::ops::Deref for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39513    type Target = SubpassShadingPipelineCreateInfoHUAWEI;
39514    fn deref(&self) -> &Self::Target {
39515        &self.inner
39516    }
39517}
39518impl<'a> ::std::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39519    fn deref_mut(&mut self) -> &mut Self::Target {
39520        &mut self.inner
39521    }
39522}
39523impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
39524    pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
39525        self.inner.render_pass = render_pass;
39526        self
39527    }
39528    pub fn subpass(mut self, subpass: u32) -> Self {
39529        self.inner.subpass = subpass;
39530        self
39531    }
39532    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39533    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39534    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39535    pub fn build(self) -> SubpassShadingPipelineCreateInfoHUAWEI {
39536        self.inner
39537    }
39538}
39539#[repr(C)]
39540#[cfg_attr(feature = "debug", derive(Debug))]
39541#[derive(Copy, Clone)]
39542#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html>"]
39543pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39544    pub s_type: StructureType,
39545    pub p_next: *mut c_void,
39546    pub max_subpass_shading_workgroup_size_aspect_ratio: u32,
39547}
39548impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39549    fn default() -> Self {
39550        Self {
39551            s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI,
39552            p_next: ::std::ptr::null_mut(),
39553            max_subpass_shading_workgroup_size_aspect_ratio: u32::default(),
39554        }
39555    }
39556}
39557impl PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39558    pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39559        PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder {
39560            inner: Self::default(),
39561            marker: ::std::marker::PhantomData,
39562        }
39563    }
39564}
39565#[repr(transparent)]
39566pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39567    inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI,
39568    marker: ::std::marker::PhantomData<&'a ()>,
39569}
39570unsafe impl ExtendsPhysicalDeviceProperties2
39571    for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'_>
39572{
39573}
39574unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI {}
39575impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39576    type Target = PhysicalDeviceSubpassShadingPropertiesHUAWEI;
39577    fn deref(&self) -> &Self::Target {
39578        &self.inner
39579    }
39580}
39581impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39582    fn deref_mut(&mut self) -> &mut Self::Target {
39583        &mut self.inner
39584    }
39585}
39586impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
39587    pub fn max_subpass_shading_workgroup_size_aspect_ratio(
39588        mut self,
39589        max_subpass_shading_workgroup_size_aspect_ratio: u32,
39590    ) -> Self {
39591        self.inner.max_subpass_shading_workgroup_size_aspect_ratio =
39592            max_subpass_shading_workgroup_size_aspect_ratio;
39593        self
39594    }
39595    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39596    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39597    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39598    pub fn build(self) -> PhysicalDeviceSubpassShadingPropertiesHUAWEI {
39599        self.inner
39600    }
39601}
39602#[repr(C)]
39603#[cfg_attr(feature = "debug", derive(Debug))]
39604#[derive(Copy, Clone)]
39605#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>"]
39606pub struct MemoryOpaqueCaptureAddressAllocateInfo {
39607    pub s_type: StructureType,
39608    pub p_next: *const c_void,
39609    pub opaque_capture_address: u64,
39610}
39611impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo {
39612    fn default() -> Self {
39613        Self {
39614            s_type: StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
39615            p_next: ::std::ptr::null(),
39616            opaque_capture_address: u64::default(),
39617        }
39618    }
39619}
39620impl MemoryOpaqueCaptureAddressAllocateInfo {
39621    pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39622        MemoryOpaqueCaptureAddressAllocateInfoBuilder {
39623            inner: Self::default(),
39624            marker: ::std::marker::PhantomData,
39625        }
39626    }
39627}
39628#[repr(transparent)]
39629pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39630    inner: MemoryOpaqueCaptureAddressAllocateInfo,
39631    marker: ::std::marker::PhantomData<&'a ()>,
39632}
39633unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {}
39634unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {}
39635impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39636    type Target = MemoryOpaqueCaptureAddressAllocateInfo;
39637    fn deref(&self) -> &Self::Target {
39638        &self.inner
39639    }
39640}
39641impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39642    fn deref_mut(&mut self) -> &mut Self::Target {
39643        &mut self.inner
39644    }
39645}
39646impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
39647    pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
39648        self.inner.opaque_capture_address = opaque_capture_address;
39649        self
39650    }
39651    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39652    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39653    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39654    pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo {
39655        self.inner
39656    }
39657}
39658#[repr(C)]
39659#[cfg_attr(feature = "debug", derive(Debug))]
39660#[derive(Copy, Clone)]
39661#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>"]
39662pub struct DeviceMemoryOpaqueCaptureAddressInfo {
39663    pub s_type: StructureType,
39664    pub p_next: *const c_void,
39665    pub memory: DeviceMemory,
39666}
39667impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo {
39668    fn default() -> Self {
39669        Self {
39670            s_type: StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
39671            p_next: ::std::ptr::null(),
39672            memory: DeviceMemory::default(),
39673        }
39674    }
39675}
39676impl DeviceMemoryOpaqueCaptureAddressInfo {
39677    pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39678        DeviceMemoryOpaqueCaptureAddressInfoBuilder {
39679            inner: Self::default(),
39680            marker: ::std::marker::PhantomData,
39681        }
39682    }
39683}
39684#[repr(transparent)]
39685pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39686    inner: DeviceMemoryOpaqueCaptureAddressInfo,
39687    marker: ::std::marker::PhantomData<&'a ()>,
39688}
39689impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39690    type Target = DeviceMemoryOpaqueCaptureAddressInfo;
39691    fn deref(&self) -> &Self::Target {
39692        &self.inner
39693    }
39694}
39695impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39696    fn deref_mut(&mut self) -> &mut Self::Target {
39697        &mut self.inner
39698    }
39699}
39700impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
39701    pub fn memory(mut self, memory: DeviceMemory) -> Self {
39702        self.inner.memory = memory;
39703        self
39704    }
39705    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39706    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39707    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39708    pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo {
39709        self.inner
39710    }
39711}
39712#[repr(C)]
39713#[cfg_attr(feature = "debug", derive(Debug))]
39714#[derive(Copy, Clone)]
39715#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>"]
39716pub struct PhysicalDeviceLineRasterizationFeaturesEXT {
39717    pub s_type: StructureType,
39718    pub p_next: *mut c_void,
39719    pub rectangular_lines: Bool32,
39720    pub bresenham_lines: Bool32,
39721    pub smooth_lines: Bool32,
39722    pub stippled_rectangular_lines: Bool32,
39723    pub stippled_bresenham_lines: Bool32,
39724    pub stippled_smooth_lines: Bool32,
39725}
39726impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT {
39727    fn default() -> Self {
39728        Self {
39729            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
39730            p_next: ::std::ptr::null_mut(),
39731            rectangular_lines: Bool32::default(),
39732            bresenham_lines: Bool32::default(),
39733            smooth_lines: Bool32::default(),
39734            stippled_rectangular_lines: Bool32::default(),
39735            stippled_bresenham_lines: Bool32::default(),
39736            stippled_smooth_lines: Bool32::default(),
39737        }
39738    }
39739}
39740impl PhysicalDeviceLineRasterizationFeaturesEXT {
39741    pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39742        PhysicalDeviceLineRasterizationFeaturesEXTBuilder {
39743            inner: Self::default(),
39744            marker: ::std::marker::PhantomData,
39745        }
39746    }
39747}
39748#[repr(transparent)]
39749pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39750    inner: PhysicalDeviceLineRasterizationFeaturesEXT,
39751    marker: ::std::marker::PhantomData<&'a ()>,
39752}
39753unsafe impl ExtendsPhysicalDeviceFeatures2
39754    for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_>
39755{
39756}
39757unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT {}
39758unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {}
39759unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {}
39760impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39761    type Target = PhysicalDeviceLineRasterizationFeaturesEXT;
39762    fn deref(&self) -> &Self::Target {
39763        &self.inner
39764    }
39765}
39766impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39767    fn deref_mut(&mut self) -> &mut Self::Target {
39768        &mut self.inner
39769    }
39770}
39771impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
39772    pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self {
39773        self.inner.rectangular_lines = rectangular_lines.into();
39774        self
39775    }
39776    pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self {
39777        self.inner.bresenham_lines = bresenham_lines.into();
39778        self
39779    }
39780    pub fn smooth_lines(mut self, smooth_lines: bool) -> Self {
39781        self.inner.smooth_lines = smooth_lines.into();
39782        self
39783    }
39784    pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self {
39785        self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into();
39786        self
39787    }
39788    pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self {
39789        self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into();
39790        self
39791    }
39792    pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self {
39793        self.inner.stippled_smooth_lines = stippled_smooth_lines.into();
39794        self
39795    }
39796    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39797    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39798    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39799    pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT {
39800        self.inner
39801    }
39802}
39803#[repr(C)]
39804#[cfg_attr(feature = "debug", derive(Debug))]
39805#[derive(Copy, Clone)]
39806#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>"]
39807pub struct PhysicalDeviceLineRasterizationPropertiesEXT {
39808    pub s_type: StructureType,
39809    pub p_next: *mut c_void,
39810    pub line_sub_pixel_precision_bits: u32,
39811}
39812impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT {
39813    fn default() -> Self {
39814        Self {
39815            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
39816            p_next: ::std::ptr::null_mut(),
39817            line_sub_pixel_precision_bits: u32::default(),
39818        }
39819    }
39820}
39821impl PhysicalDeviceLineRasterizationPropertiesEXT {
39822    pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39823        PhysicalDeviceLineRasterizationPropertiesEXTBuilder {
39824            inner: Self::default(),
39825            marker: ::std::marker::PhantomData,
39826        }
39827    }
39828}
39829#[repr(transparent)]
39830pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39831    inner: PhysicalDeviceLineRasterizationPropertiesEXT,
39832    marker: ::std::marker::PhantomData<&'a ()>,
39833}
39834unsafe impl ExtendsPhysicalDeviceProperties2
39835    for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_>
39836{
39837}
39838unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {}
39839impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39840    type Target = PhysicalDeviceLineRasterizationPropertiesEXT;
39841    fn deref(&self) -> &Self::Target {
39842        &self.inner
39843    }
39844}
39845impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39846    fn deref_mut(&mut self) -> &mut Self::Target {
39847        &mut self.inner
39848    }
39849}
39850impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
39851    pub fn line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self {
39852        self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits;
39853        self
39854    }
39855    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39856    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39857    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39858    pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT {
39859        self.inner
39860    }
39861}
39862#[repr(C)]
39863#[cfg_attr(feature = "debug", derive(Debug))]
39864#[derive(Copy, Clone)]
39865#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>"]
39866pub struct PipelineRasterizationLineStateCreateInfoEXT {
39867    pub s_type: StructureType,
39868    pub p_next: *const c_void,
39869    pub line_rasterization_mode: LineRasterizationModeEXT,
39870    pub stippled_line_enable: Bool32,
39871    pub line_stipple_factor: u32,
39872    pub line_stipple_pattern: u16,
39873}
39874impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT {
39875    fn default() -> Self {
39876        Self {
39877            s_type: StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
39878            p_next: ::std::ptr::null(),
39879            line_rasterization_mode: LineRasterizationModeEXT::default(),
39880            stippled_line_enable: Bool32::default(),
39881            line_stipple_factor: u32::default(),
39882            line_stipple_pattern: u16::default(),
39883        }
39884    }
39885}
39886impl PipelineRasterizationLineStateCreateInfoEXT {
39887    pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39888        PipelineRasterizationLineStateCreateInfoEXTBuilder {
39889            inner: Self::default(),
39890            marker: ::std::marker::PhantomData,
39891        }
39892    }
39893}
39894#[repr(transparent)]
39895pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39896    inner: PipelineRasterizationLineStateCreateInfoEXT,
39897    marker: ::std::marker::PhantomData<&'a ()>,
39898}
39899unsafe impl ExtendsPipelineRasterizationStateCreateInfo
39900    for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_>
39901{
39902}
39903unsafe impl ExtendsPipelineRasterizationStateCreateInfo
39904    for PipelineRasterizationLineStateCreateInfoEXT
39905{
39906}
39907impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39908    type Target = PipelineRasterizationLineStateCreateInfoEXT;
39909    fn deref(&self) -> &Self::Target {
39910        &self.inner
39911    }
39912}
39913impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39914    fn deref_mut(&mut self) -> &mut Self::Target {
39915        &mut self.inner
39916    }
39917}
39918impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
39919    pub fn line_rasterization_mode(
39920        mut self,
39921        line_rasterization_mode: LineRasterizationModeEXT,
39922    ) -> Self {
39923        self.inner.line_rasterization_mode = line_rasterization_mode;
39924        self
39925    }
39926    pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self {
39927        self.inner.stippled_line_enable = stippled_line_enable.into();
39928        self
39929    }
39930    pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self {
39931        self.inner.line_stipple_factor = line_stipple_factor;
39932        self
39933    }
39934    pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self {
39935        self.inner.line_stipple_pattern = line_stipple_pattern;
39936        self
39937    }
39938    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39939    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39940    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
39941    pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT {
39942        self.inner
39943    }
39944}
39945#[repr(C)]
39946#[cfg_attr(feature = "debug", derive(Debug))]
39947#[derive(Copy, Clone)]
39948#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeatures.html>"]
39949pub struct PhysicalDevicePipelineCreationCacheControlFeatures {
39950    pub s_type: StructureType,
39951    pub p_next: *mut c_void,
39952    pub pipeline_creation_cache_control: Bool32,
39953}
39954impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures {
39955    fn default() -> Self {
39956        Self {
39957            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES,
39958            p_next: ::std::ptr::null_mut(),
39959            pipeline_creation_cache_control: Bool32::default(),
39960        }
39961    }
39962}
39963impl PhysicalDevicePipelineCreationCacheControlFeatures {
39964    pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39965        PhysicalDevicePipelineCreationCacheControlFeaturesBuilder {
39966            inner: Self::default(),
39967            marker: ::std::marker::PhantomData,
39968        }
39969    }
39970}
39971#[repr(transparent)]
39972pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39973    inner: PhysicalDevicePipelineCreationCacheControlFeatures,
39974    marker: ::std::marker::PhantomData<&'a ()>,
39975}
39976unsafe impl ExtendsPhysicalDeviceFeatures2
39977    for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
39978{
39979}
39980unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures {}
39981unsafe impl ExtendsDeviceCreateInfo
39982    for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
39983{
39984}
39985unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures {}
39986impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39987    type Target = PhysicalDevicePipelineCreationCacheControlFeatures;
39988    fn deref(&self) -> &Self::Target {
39989        &self.inner
39990    }
39991}
39992impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39993    fn deref_mut(&mut self) -> &mut Self::Target {
39994        &mut self.inner
39995    }
39996}
39997impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
39998    pub fn pipeline_creation_cache_control(
39999        mut self,
40000        pipeline_creation_cache_control: bool,
40001    ) -> Self {
40002        self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
40003        self
40004    }
40005    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40006    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40007    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40008    pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures {
40009        self.inner
40010    }
40011}
40012#[repr(C)]
40013#[cfg_attr(feature = "debug", derive(Debug))]
40014#[derive(Copy, Clone)]
40015#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Features.html>"]
40016pub struct PhysicalDeviceVulkan11Features {
40017    pub s_type: StructureType,
40018    pub p_next: *mut c_void,
40019    pub storage_buffer16_bit_access: Bool32,
40020    pub uniform_and_storage_buffer16_bit_access: Bool32,
40021    pub storage_push_constant16: Bool32,
40022    pub storage_input_output16: Bool32,
40023    pub multiview: Bool32,
40024    pub multiview_geometry_shader: Bool32,
40025    pub multiview_tessellation_shader: Bool32,
40026    pub variable_pointers_storage_buffer: Bool32,
40027    pub variable_pointers: Bool32,
40028    pub protected_memory: Bool32,
40029    pub sampler_ycbcr_conversion: Bool32,
40030    pub shader_draw_parameters: Bool32,
40031}
40032impl ::std::default::Default for PhysicalDeviceVulkan11Features {
40033    fn default() -> Self {
40034        Self {
40035            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
40036            p_next: ::std::ptr::null_mut(),
40037            storage_buffer16_bit_access: Bool32::default(),
40038            uniform_and_storage_buffer16_bit_access: Bool32::default(),
40039            storage_push_constant16: Bool32::default(),
40040            storage_input_output16: Bool32::default(),
40041            multiview: Bool32::default(),
40042            multiview_geometry_shader: Bool32::default(),
40043            multiview_tessellation_shader: Bool32::default(),
40044            variable_pointers_storage_buffer: Bool32::default(),
40045            variable_pointers: Bool32::default(),
40046            protected_memory: Bool32::default(),
40047            sampler_ycbcr_conversion: Bool32::default(),
40048            shader_draw_parameters: Bool32::default(),
40049        }
40050    }
40051}
40052impl PhysicalDeviceVulkan11Features {
40053    pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40054        PhysicalDeviceVulkan11FeaturesBuilder {
40055            inner: Self::default(),
40056            marker: ::std::marker::PhantomData,
40057        }
40058    }
40059}
40060#[repr(transparent)]
40061pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40062    inner: PhysicalDeviceVulkan11Features,
40063    marker: ::std::marker::PhantomData<&'a ()>,
40064}
40065unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
40066unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features {}
40067unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
40068unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {}
40069impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40070    type Target = PhysicalDeviceVulkan11Features;
40071    fn deref(&self) -> &Self::Target {
40072        &self.inner
40073    }
40074}
40075impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40076    fn deref_mut(&mut self) -> &mut Self::Target {
40077        &mut self.inner
40078    }
40079}
40080impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
40081    pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
40082        self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
40083        self
40084    }
40085    pub fn uniform_and_storage_buffer16_bit_access(
40086        mut self,
40087        uniform_and_storage_buffer16_bit_access: bool,
40088    ) -> Self {
40089        self.inner.uniform_and_storage_buffer16_bit_access =
40090            uniform_and_storage_buffer16_bit_access.into();
40091        self
40092    }
40093    pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
40094        self.inner.storage_push_constant16 = storage_push_constant16.into();
40095        self
40096    }
40097    pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
40098        self.inner.storage_input_output16 = storage_input_output16.into();
40099        self
40100    }
40101    pub fn multiview(mut self, multiview: bool) -> Self {
40102        self.inner.multiview = multiview.into();
40103        self
40104    }
40105    pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
40106        self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
40107        self
40108    }
40109    pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
40110        self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
40111        self
40112    }
40113    pub fn variable_pointers_storage_buffer(
40114        mut self,
40115        variable_pointers_storage_buffer: bool,
40116    ) -> Self {
40117        self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
40118        self
40119    }
40120    pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
40121        self.inner.variable_pointers = variable_pointers.into();
40122        self
40123    }
40124    pub fn protected_memory(mut self, protected_memory: bool) -> Self {
40125        self.inner.protected_memory = protected_memory.into();
40126        self
40127    }
40128    pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
40129        self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
40130        self
40131    }
40132    pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
40133        self.inner.shader_draw_parameters = shader_draw_parameters.into();
40134        self
40135    }
40136    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40137    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40138    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40139    pub fn build(self) -> PhysicalDeviceVulkan11Features {
40140        self.inner
40141    }
40142}
40143#[repr(C)]
40144#[cfg_attr(feature = "debug", derive(Debug))]
40145#[derive(Copy, Clone)]
40146#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html>"]
40147pub struct PhysicalDeviceVulkan11Properties {
40148    pub s_type: StructureType,
40149    pub p_next: *mut c_void,
40150    pub device_uuid: [u8; UUID_SIZE],
40151    pub driver_uuid: [u8; UUID_SIZE],
40152    pub device_luid: [u8; LUID_SIZE],
40153    pub device_node_mask: u32,
40154    pub device_luid_valid: Bool32,
40155    pub subgroup_size: u32,
40156    pub subgroup_supported_stages: ShaderStageFlags,
40157    pub subgroup_supported_operations: SubgroupFeatureFlags,
40158    pub subgroup_quad_operations_in_all_stages: Bool32,
40159    pub point_clipping_behavior: PointClippingBehavior,
40160    pub max_multiview_view_count: u32,
40161    pub max_multiview_instance_index: u32,
40162    pub protected_no_fault: Bool32,
40163    pub max_per_set_descriptors: u32,
40164    pub max_memory_allocation_size: DeviceSize,
40165}
40166impl ::std::default::Default for PhysicalDeviceVulkan11Properties {
40167    fn default() -> Self {
40168        Self {
40169            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
40170            p_next: ::std::ptr::null_mut(),
40171            device_uuid: unsafe { ::std::mem::zeroed() },
40172            driver_uuid: unsafe { ::std::mem::zeroed() },
40173            device_luid: unsafe { ::std::mem::zeroed() },
40174            device_node_mask: u32::default(),
40175            device_luid_valid: Bool32::default(),
40176            subgroup_size: u32::default(),
40177            subgroup_supported_stages: ShaderStageFlags::default(),
40178            subgroup_supported_operations: SubgroupFeatureFlags::default(),
40179            subgroup_quad_operations_in_all_stages: Bool32::default(),
40180            point_clipping_behavior: PointClippingBehavior::default(),
40181            max_multiview_view_count: u32::default(),
40182            max_multiview_instance_index: u32::default(),
40183            protected_no_fault: Bool32::default(),
40184            max_per_set_descriptors: u32::default(),
40185            max_memory_allocation_size: DeviceSize::default(),
40186        }
40187    }
40188}
40189impl PhysicalDeviceVulkan11Properties {
40190    pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40191        PhysicalDeviceVulkan11PropertiesBuilder {
40192            inner: Self::default(),
40193            marker: ::std::marker::PhantomData,
40194        }
40195    }
40196}
40197#[repr(transparent)]
40198pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40199    inner: PhysicalDeviceVulkan11Properties,
40200    marker: ::std::marker::PhantomData<&'a ()>,
40201}
40202unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {}
40203unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {}
40204impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40205    type Target = PhysicalDeviceVulkan11Properties;
40206    fn deref(&self) -> &Self::Target {
40207        &self.inner
40208    }
40209}
40210impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40211    fn deref_mut(&mut self) -> &mut Self::Target {
40212        &mut self.inner
40213    }
40214}
40215impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
40216    pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
40217        self.inner.device_uuid = device_uuid;
40218        self
40219    }
40220    pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
40221        self.inner.driver_uuid = driver_uuid;
40222        self
40223    }
40224    pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
40225        self.inner.device_luid = device_luid;
40226        self
40227    }
40228    pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
40229        self.inner.device_node_mask = device_node_mask;
40230        self
40231    }
40232    pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
40233        self.inner.device_luid_valid = device_luid_valid.into();
40234        self
40235    }
40236    pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
40237        self.inner.subgroup_size = subgroup_size;
40238        self
40239    }
40240    pub fn subgroup_supported_stages(
40241        mut self,
40242        subgroup_supported_stages: ShaderStageFlags,
40243    ) -> Self {
40244        self.inner.subgroup_supported_stages = subgroup_supported_stages;
40245        self
40246    }
40247    pub fn subgroup_supported_operations(
40248        mut self,
40249        subgroup_supported_operations: SubgroupFeatureFlags,
40250    ) -> Self {
40251        self.inner.subgroup_supported_operations = subgroup_supported_operations;
40252        self
40253    }
40254    pub fn subgroup_quad_operations_in_all_stages(
40255        mut self,
40256        subgroup_quad_operations_in_all_stages: bool,
40257    ) -> Self {
40258        self.inner.subgroup_quad_operations_in_all_stages =
40259            subgroup_quad_operations_in_all_stages.into();
40260        self
40261    }
40262    pub fn point_clipping_behavior(
40263        mut self,
40264        point_clipping_behavior: PointClippingBehavior,
40265    ) -> Self {
40266        self.inner.point_clipping_behavior = point_clipping_behavior;
40267        self
40268    }
40269    pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
40270        self.inner.max_multiview_view_count = max_multiview_view_count;
40271        self
40272    }
40273    pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
40274        self.inner.max_multiview_instance_index = max_multiview_instance_index;
40275        self
40276    }
40277    pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
40278        self.inner.protected_no_fault = protected_no_fault.into();
40279        self
40280    }
40281    pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
40282        self.inner.max_per_set_descriptors = max_per_set_descriptors;
40283        self
40284    }
40285    pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
40286        self.inner.max_memory_allocation_size = max_memory_allocation_size;
40287        self
40288    }
40289    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40290    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40291    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40292    pub fn build(self) -> PhysicalDeviceVulkan11Properties {
40293        self.inner
40294    }
40295}
40296#[repr(C)]
40297#[cfg_attr(feature = "debug", derive(Debug))]
40298#[derive(Copy, Clone)]
40299#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Features.html>"]
40300pub struct PhysicalDeviceVulkan12Features {
40301    pub s_type: StructureType,
40302    pub p_next: *mut c_void,
40303    pub sampler_mirror_clamp_to_edge: Bool32,
40304    pub draw_indirect_count: Bool32,
40305    pub storage_buffer8_bit_access: Bool32,
40306    pub uniform_and_storage_buffer8_bit_access: Bool32,
40307    pub storage_push_constant8: Bool32,
40308    pub shader_buffer_int64_atomics: Bool32,
40309    pub shader_shared_int64_atomics: Bool32,
40310    pub shader_float16: Bool32,
40311    pub shader_int8: Bool32,
40312    pub descriptor_indexing: Bool32,
40313    pub shader_input_attachment_array_dynamic_indexing: Bool32,
40314    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
40315    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
40316    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
40317    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
40318    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
40319    pub shader_storage_image_array_non_uniform_indexing: Bool32,
40320    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
40321    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
40322    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
40323    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
40324    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
40325    pub descriptor_binding_storage_image_update_after_bind: Bool32,
40326    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
40327    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
40328    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
40329    pub descriptor_binding_update_unused_while_pending: Bool32,
40330    pub descriptor_binding_partially_bound: Bool32,
40331    pub descriptor_binding_variable_descriptor_count: Bool32,
40332    pub runtime_descriptor_array: Bool32,
40333    pub sampler_filter_minmax: Bool32,
40334    pub scalar_block_layout: Bool32,
40335    pub imageless_framebuffer: Bool32,
40336    pub uniform_buffer_standard_layout: Bool32,
40337    pub shader_subgroup_extended_types: Bool32,
40338    pub separate_depth_stencil_layouts: Bool32,
40339    pub host_query_reset: Bool32,
40340    pub timeline_semaphore: Bool32,
40341    pub buffer_device_address: Bool32,
40342    pub buffer_device_address_capture_replay: Bool32,
40343    pub buffer_device_address_multi_device: Bool32,
40344    pub vulkan_memory_model: Bool32,
40345    pub vulkan_memory_model_device_scope: Bool32,
40346    pub vulkan_memory_model_availability_visibility_chains: Bool32,
40347    pub shader_output_viewport_index: Bool32,
40348    pub shader_output_layer: Bool32,
40349    pub subgroup_broadcast_dynamic_id: Bool32,
40350}
40351impl ::std::default::Default for PhysicalDeviceVulkan12Features {
40352    fn default() -> Self {
40353        Self {
40354            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
40355            p_next: ::std::ptr::null_mut(),
40356            sampler_mirror_clamp_to_edge: Bool32::default(),
40357            draw_indirect_count: Bool32::default(),
40358            storage_buffer8_bit_access: Bool32::default(),
40359            uniform_and_storage_buffer8_bit_access: Bool32::default(),
40360            storage_push_constant8: Bool32::default(),
40361            shader_buffer_int64_atomics: Bool32::default(),
40362            shader_shared_int64_atomics: Bool32::default(),
40363            shader_float16: Bool32::default(),
40364            shader_int8: Bool32::default(),
40365            descriptor_indexing: Bool32::default(),
40366            shader_input_attachment_array_dynamic_indexing: Bool32::default(),
40367            shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
40368            shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
40369            shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
40370            shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
40371            shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
40372            shader_storage_image_array_non_uniform_indexing: Bool32::default(),
40373            shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
40374            shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
40375            shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
40376            descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
40377            descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
40378            descriptor_binding_storage_image_update_after_bind: Bool32::default(),
40379            descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
40380            descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
40381            descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
40382            descriptor_binding_update_unused_while_pending: Bool32::default(),
40383            descriptor_binding_partially_bound: Bool32::default(),
40384            descriptor_binding_variable_descriptor_count: Bool32::default(),
40385            runtime_descriptor_array: Bool32::default(),
40386            sampler_filter_minmax: Bool32::default(),
40387            scalar_block_layout: Bool32::default(),
40388            imageless_framebuffer: Bool32::default(),
40389            uniform_buffer_standard_layout: Bool32::default(),
40390            shader_subgroup_extended_types: Bool32::default(),
40391            separate_depth_stencil_layouts: Bool32::default(),
40392            host_query_reset: Bool32::default(),
40393            timeline_semaphore: Bool32::default(),
40394            buffer_device_address: Bool32::default(),
40395            buffer_device_address_capture_replay: Bool32::default(),
40396            buffer_device_address_multi_device: Bool32::default(),
40397            vulkan_memory_model: Bool32::default(),
40398            vulkan_memory_model_device_scope: Bool32::default(),
40399            vulkan_memory_model_availability_visibility_chains: Bool32::default(),
40400            shader_output_viewport_index: Bool32::default(),
40401            shader_output_layer: Bool32::default(),
40402            subgroup_broadcast_dynamic_id: Bool32::default(),
40403        }
40404    }
40405}
40406impl PhysicalDeviceVulkan12Features {
40407    pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40408        PhysicalDeviceVulkan12FeaturesBuilder {
40409            inner: Self::default(),
40410            marker: ::std::marker::PhantomData,
40411        }
40412    }
40413}
40414#[repr(transparent)]
40415pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40416    inner: PhysicalDeviceVulkan12Features,
40417    marker: ::std::marker::PhantomData<&'a ()>,
40418}
40419unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
40420unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features {}
40421unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
40422unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {}
40423impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40424    type Target = PhysicalDeviceVulkan12Features;
40425    fn deref(&self) -> &Self::Target {
40426        &self.inner
40427    }
40428}
40429impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40430    fn deref_mut(&mut self) -> &mut Self::Target {
40431        &mut self.inner
40432    }
40433}
40434impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
40435    pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self {
40436        self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into();
40437        self
40438    }
40439    pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self {
40440        self.inner.draw_indirect_count = draw_indirect_count.into();
40441        self
40442    }
40443    pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
40444        self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
40445        self
40446    }
40447    pub fn uniform_and_storage_buffer8_bit_access(
40448        mut self,
40449        uniform_and_storage_buffer8_bit_access: bool,
40450    ) -> Self {
40451        self.inner.uniform_and_storage_buffer8_bit_access =
40452            uniform_and_storage_buffer8_bit_access.into();
40453        self
40454    }
40455    pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
40456        self.inner.storage_push_constant8 = storage_push_constant8.into();
40457        self
40458    }
40459    pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
40460        self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
40461        self
40462    }
40463    pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
40464        self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
40465        self
40466    }
40467    pub fn shader_float16(mut self, shader_float16: bool) -> Self {
40468        self.inner.shader_float16 = shader_float16.into();
40469        self
40470    }
40471    pub fn shader_int8(mut self, shader_int8: bool) -> Self {
40472        self.inner.shader_int8 = shader_int8.into();
40473        self
40474    }
40475    pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self {
40476        self.inner.descriptor_indexing = descriptor_indexing.into();
40477        self
40478    }
40479    pub fn shader_input_attachment_array_dynamic_indexing(
40480        mut self,
40481        shader_input_attachment_array_dynamic_indexing: bool,
40482    ) -> Self {
40483        self.inner.shader_input_attachment_array_dynamic_indexing =
40484            shader_input_attachment_array_dynamic_indexing.into();
40485        self
40486    }
40487    pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
40488        mut self,
40489        shader_uniform_texel_buffer_array_dynamic_indexing: bool,
40490    ) -> Self {
40491        self.inner
40492            .shader_uniform_texel_buffer_array_dynamic_indexing =
40493            shader_uniform_texel_buffer_array_dynamic_indexing.into();
40494        self
40495    }
40496    pub fn shader_storage_texel_buffer_array_dynamic_indexing(
40497        mut self,
40498        shader_storage_texel_buffer_array_dynamic_indexing: bool,
40499    ) -> Self {
40500        self.inner
40501            .shader_storage_texel_buffer_array_dynamic_indexing =
40502            shader_storage_texel_buffer_array_dynamic_indexing.into();
40503        self
40504    }
40505    pub fn shader_uniform_buffer_array_non_uniform_indexing(
40506        mut self,
40507        shader_uniform_buffer_array_non_uniform_indexing: bool,
40508    ) -> Self {
40509        self.inner.shader_uniform_buffer_array_non_uniform_indexing =
40510            shader_uniform_buffer_array_non_uniform_indexing.into();
40511        self
40512    }
40513    pub fn shader_sampled_image_array_non_uniform_indexing(
40514        mut self,
40515        shader_sampled_image_array_non_uniform_indexing: bool,
40516    ) -> Self {
40517        self.inner.shader_sampled_image_array_non_uniform_indexing =
40518            shader_sampled_image_array_non_uniform_indexing.into();
40519        self
40520    }
40521    pub fn shader_storage_buffer_array_non_uniform_indexing(
40522        mut self,
40523        shader_storage_buffer_array_non_uniform_indexing: bool,
40524    ) -> Self {
40525        self.inner.shader_storage_buffer_array_non_uniform_indexing =
40526            shader_storage_buffer_array_non_uniform_indexing.into();
40527        self
40528    }
40529    pub fn shader_storage_image_array_non_uniform_indexing(
40530        mut self,
40531        shader_storage_image_array_non_uniform_indexing: bool,
40532    ) -> Self {
40533        self.inner.shader_storage_image_array_non_uniform_indexing =
40534            shader_storage_image_array_non_uniform_indexing.into();
40535        self
40536    }
40537    pub fn shader_input_attachment_array_non_uniform_indexing(
40538        mut self,
40539        shader_input_attachment_array_non_uniform_indexing: bool,
40540    ) -> Self {
40541        self.inner
40542            .shader_input_attachment_array_non_uniform_indexing =
40543            shader_input_attachment_array_non_uniform_indexing.into();
40544        self
40545    }
40546    pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
40547        mut self,
40548        shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
40549    ) -> Self {
40550        self.inner
40551            .shader_uniform_texel_buffer_array_non_uniform_indexing =
40552            shader_uniform_texel_buffer_array_non_uniform_indexing.into();
40553        self
40554    }
40555    pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
40556        mut self,
40557        shader_storage_texel_buffer_array_non_uniform_indexing: bool,
40558    ) -> Self {
40559        self.inner
40560            .shader_storage_texel_buffer_array_non_uniform_indexing =
40561            shader_storage_texel_buffer_array_non_uniform_indexing.into();
40562        self
40563    }
40564    pub fn descriptor_binding_uniform_buffer_update_after_bind(
40565        mut self,
40566        descriptor_binding_uniform_buffer_update_after_bind: bool,
40567    ) -> Self {
40568        self.inner
40569            .descriptor_binding_uniform_buffer_update_after_bind =
40570            descriptor_binding_uniform_buffer_update_after_bind.into();
40571        self
40572    }
40573    pub fn descriptor_binding_sampled_image_update_after_bind(
40574        mut self,
40575        descriptor_binding_sampled_image_update_after_bind: bool,
40576    ) -> Self {
40577        self.inner
40578            .descriptor_binding_sampled_image_update_after_bind =
40579            descriptor_binding_sampled_image_update_after_bind.into();
40580        self
40581    }
40582    pub fn descriptor_binding_storage_image_update_after_bind(
40583        mut self,
40584        descriptor_binding_storage_image_update_after_bind: bool,
40585    ) -> Self {
40586        self.inner
40587            .descriptor_binding_storage_image_update_after_bind =
40588            descriptor_binding_storage_image_update_after_bind.into();
40589        self
40590    }
40591    pub fn descriptor_binding_storage_buffer_update_after_bind(
40592        mut self,
40593        descriptor_binding_storage_buffer_update_after_bind: bool,
40594    ) -> Self {
40595        self.inner
40596            .descriptor_binding_storage_buffer_update_after_bind =
40597            descriptor_binding_storage_buffer_update_after_bind.into();
40598        self
40599    }
40600    pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
40601        mut self,
40602        descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
40603    ) -> Self {
40604        self.inner
40605            .descriptor_binding_uniform_texel_buffer_update_after_bind =
40606            descriptor_binding_uniform_texel_buffer_update_after_bind.into();
40607        self
40608    }
40609    pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
40610        mut self,
40611        descriptor_binding_storage_texel_buffer_update_after_bind: bool,
40612    ) -> Self {
40613        self.inner
40614            .descriptor_binding_storage_texel_buffer_update_after_bind =
40615            descriptor_binding_storage_texel_buffer_update_after_bind.into();
40616        self
40617    }
40618    pub fn descriptor_binding_update_unused_while_pending(
40619        mut self,
40620        descriptor_binding_update_unused_while_pending: bool,
40621    ) -> Self {
40622        self.inner.descriptor_binding_update_unused_while_pending =
40623            descriptor_binding_update_unused_while_pending.into();
40624        self
40625    }
40626    pub fn descriptor_binding_partially_bound(
40627        mut self,
40628        descriptor_binding_partially_bound: bool,
40629    ) -> Self {
40630        self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
40631        self
40632    }
40633    pub fn descriptor_binding_variable_descriptor_count(
40634        mut self,
40635        descriptor_binding_variable_descriptor_count: bool,
40636    ) -> Self {
40637        self.inner.descriptor_binding_variable_descriptor_count =
40638            descriptor_binding_variable_descriptor_count.into();
40639        self
40640    }
40641    pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
40642        self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
40643        self
40644    }
40645    pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self {
40646        self.inner.sampler_filter_minmax = sampler_filter_minmax.into();
40647        self
40648    }
40649    pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
40650        self.inner.scalar_block_layout = scalar_block_layout.into();
40651        self
40652    }
40653    pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
40654        self.inner.imageless_framebuffer = imageless_framebuffer.into();
40655        self
40656    }
40657    pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
40658        self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
40659        self
40660    }
40661    pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
40662        self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
40663        self
40664    }
40665    pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
40666        self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
40667        self
40668    }
40669    pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
40670        self.inner.host_query_reset = host_query_reset.into();
40671        self
40672    }
40673    pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
40674        self.inner.timeline_semaphore = timeline_semaphore.into();
40675        self
40676    }
40677    pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
40678        self.inner.buffer_device_address = buffer_device_address.into();
40679        self
40680    }
40681    pub fn buffer_device_address_capture_replay(
40682        mut self,
40683        buffer_device_address_capture_replay: bool,
40684    ) -> Self {
40685        self.inner.buffer_device_address_capture_replay =
40686            buffer_device_address_capture_replay.into();
40687        self
40688    }
40689    pub fn buffer_device_address_multi_device(
40690        mut self,
40691        buffer_device_address_multi_device: bool,
40692    ) -> Self {
40693        self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
40694        self
40695    }
40696    pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
40697        self.inner.vulkan_memory_model = vulkan_memory_model.into();
40698        self
40699    }
40700    pub fn vulkan_memory_model_device_scope(
40701        mut self,
40702        vulkan_memory_model_device_scope: bool,
40703    ) -> Self {
40704        self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
40705        self
40706    }
40707    pub fn vulkan_memory_model_availability_visibility_chains(
40708        mut self,
40709        vulkan_memory_model_availability_visibility_chains: bool,
40710    ) -> Self {
40711        self.inner
40712            .vulkan_memory_model_availability_visibility_chains =
40713            vulkan_memory_model_availability_visibility_chains.into();
40714        self
40715    }
40716    pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self {
40717        self.inner.shader_output_viewport_index = shader_output_viewport_index.into();
40718        self
40719    }
40720    pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self {
40721        self.inner.shader_output_layer = shader_output_layer.into();
40722        self
40723    }
40724    pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self {
40725        self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into();
40726        self
40727    }
40728    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40729    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40730    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
40731    pub fn build(self) -> PhysicalDeviceVulkan12Features {
40732        self.inner
40733    }
40734}
40735#[repr(C)]
40736#[derive(Copy, Clone)]
40737#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html>"]
40738pub struct PhysicalDeviceVulkan12Properties {
40739    pub s_type: StructureType,
40740    pub p_next: *mut c_void,
40741    pub driver_id: DriverId,
40742    pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
40743    pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
40744    pub conformance_version: ConformanceVersion,
40745    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
40746    pub rounding_mode_independence: ShaderFloatControlsIndependence,
40747    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
40748    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
40749    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
40750    pub shader_denorm_preserve_float16: Bool32,
40751    pub shader_denorm_preserve_float32: Bool32,
40752    pub shader_denorm_preserve_float64: Bool32,
40753    pub shader_denorm_flush_to_zero_float16: Bool32,
40754    pub shader_denorm_flush_to_zero_float32: Bool32,
40755    pub shader_denorm_flush_to_zero_float64: Bool32,
40756    pub shader_rounding_mode_rte_float16: Bool32,
40757    pub shader_rounding_mode_rte_float32: Bool32,
40758    pub shader_rounding_mode_rte_float64: Bool32,
40759    pub shader_rounding_mode_rtz_float16: Bool32,
40760    pub shader_rounding_mode_rtz_float32: Bool32,
40761    pub shader_rounding_mode_rtz_float64: Bool32,
40762    pub max_update_after_bind_descriptors_in_all_pools: u32,
40763    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
40764    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
40765    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
40766    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
40767    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
40768    pub robust_buffer_access_update_after_bind: Bool32,
40769    pub quad_divergent_implicit_lod: Bool32,
40770    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
40771    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
40772    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
40773    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
40774    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
40775    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
40776    pub max_per_stage_update_after_bind_resources: u32,
40777    pub max_descriptor_set_update_after_bind_samplers: u32,
40778    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
40779    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
40780    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
40781    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
40782    pub max_descriptor_set_update_after_bind_sampled_images: u32,
40783    pub max_descriptor_set_update_after_bind_storage_images: u32,
40784    pub max_descriptor_set_update_after_bind_input_attachments: u32,
40785    pub supported_depth_resolve_modes: ResolveModeFlags,
40786    pub supported_stencil_resolve_modes: ResolveModeFlags,
40787    pub independent_resolve_none: Bool32,
40788    pub independent_resolve: Bool32,
40789    pub filter_minmax_single_component_formats: Bool32,
40790    pub filter_minmax_image_component_mapping: Bool32,
40791    pub max_timeline_semaphore_value_difference: u64,
40792    pub framebuffer_integer_color_sample_counts: SampleCountFlags,
40793}
40794#[cfg(feature = "debug")]
40795impl fmt::Debug for PhysicalDeviceVulkan12Properties {
40796    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
40797        fmt.debug_struct("PhysicalDeviceVulkan12Properties")
40798            .field("s_type", &self.s_type)
40799            .field("p_next", &self.p_next)
40800            .field("driver_id", &self.driver_id)
40801            .field("driver_name", &unsafe {
40802                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
40803            })
40804            .field("driver_info", &unsafe {
40805                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
40806            })
40807            .field("conformance_version", &self.conformance_version)
40808            .field(
40809                "denorm_behavior_independence",
40810                &self.denorm_behavior_independence,
40811            )
40812            .field(
40813                "rounding_mode_independence",
40814                &self.rounding_mode_independence,
40815            )
40816            .field(
40817                "shader_signed_zero_inf_nan_preserve_float16",
40818                &self.shader_signed_zero_inf_nan_preserve_float16,
40819            )
40820            .field(
40821                "shader_signed_zero_inf_nan_preserve_float32",
40822                &self.shader_signed_zero_inf_nan_preserve_float32,
40823            )
40824            .field(
40825                "shader_signed_zero_inf_nan_preserve_float64",
40826                &self.shader_signed_zero_inf_nan_preserve_float64,
40827            )
40828            .field(
40829                "shader_denorm_preserve_float16",
40830                &self.shader_denorm_preserve_float16,
40831            )
40832            .field(
40833                "shader_denorm_preserve_float32",
40834                &self.shader_denorm_preserve_float32,
40835            )
40836            .field(
40837                "shader_denorm_preserve_float64",
40838                &self.shader_denorm_preserve_float64,
40839            )
40840            .field(
40841                "shader_denorm_flush_to_zero_float16",
40842                &self.shader_denorm_flush_to_zero_float16,
40843            )
40844            .field(
40845                "shader_denorm_flush_to_zero_float32",
40846                &self.shader_denorm_flush_to_zero_float32,
40847            )
40848            .field(
40849                "shader_denorm_flush_to_zero_float64",
40850                &self.shader_denorm_flush_to_zero_float64,
40851            )
40852            .field(
40853                "shader_rounding_mode_rte_float16",
40854                &self.shader_rounding_mode_rte_float16,
40855            )
40856            .field(
40857                "shader_rounding_mode_rte_float32",
40858                &self.shader_rounding_mode_rte_float32,
40859            )
40860            .field(
40861                "shader_rounding_mode_rte_float64",
40862                &self.shader_rounding_mode_rte_float64,
40863            )
40864            .field(
40865                "shader_rounding_mode_rtz_float16",
40866                &self.shader_rounding_mode_rtz_float16,
40867            )
40868            .field(
40869                "shader_rounding_mode_rtz_float32",
40870                &self.shader_rounding_mode_rtz_float32,
40871            )
40872            .field(
40873                "shader_rounding_mode_rtz_float64",
40874                &self.shader_rounding_mode_rtz_float64,
40875            )
40876            .field(
40877                "max_update_after_bind_descriptors_in_all_pools",
40878                &self.max_update_after_bind_descriptors_in_all_pools,
40879            )
40880            .field(
40881                "shader_uniform_buffer_array_non_uniform_indexing_native",
40882                &self.shader_uniform_buffer_array_non_uniform_indexing_native,
40883            )
40884            .field(
40885                "shader_sampled_image_array_non_uniform_indexing_native",
40886                &self.shader_sampled_image_array_non_uniform_indexing_native,
40887            )
40888            .field(
40889                "shader_storage_buffer_array_non_uniform_indexing_native",
40890                &self.shader_storage_buffer_array_non_uniform_indexing_native,
40891            )
40892            .field(
40893                "shader_storage_image_array_non_uniform_indexing_native",
40894                &self.shader_storage_image_array_non_uniform_indexing_native,
40895            )
40896            .field(
40897                "shader_input_attachment_array_non_uniform_indexing_native",
40898                &self.shader_input_attachment_array_non_uniform_indexing_native,
40899            )
40900            .field(
40901                "robust_buffer_access_update_after_bind",
40902                &self.robust_buffer_access_update_after_bind,
40903            )
40904            .field(
40905                "quad_divergent_implicit_lod",
40906                &self.quad_divergent_implicit_lod,
40907            )
40908            .field(
40909                "max_per_stage_descriptor_update_after_bind_samplers",
40910                &self.max_per_stage_descriptor_update_after_bind_samplers,
40911            )
40912            .field(
40913                "max_per_stage_descriptor_update_after_bind_uniform_buffers",
40914                &self.max_per_stage_descriptor_update_after_bind_uniform_buffers,
40915            )
40916            .field(
40917                "max_per_stage_descriptor_update_after_bind_storage_buffers",
40918                &self.max_per_stage_descriptor_update_after_bind_storage_buffers,
40919            )
40920            .field(
40921                "max_per_stage_descriptor_update_after_bind_sampled_images",
40922                &self.max_per_stage_descriptor_update_after_bind_sampled_images,
40923            )
40924            .field(
40925                "max_per_stage_descriptor_update_after_bind_storage_images",
40926                &self.max_per_stage_descriptor_update_after_bind_storage_images,
40927            )
40928            .field(
40929                "max_per_stage_descriptor_update_after_bind_input_attachments",
40930                &self.max_per_stage_descriptor_update_after_bind_input_attachments,
40931            )
40932            .field(
40933                "max_per_stage_update_after_bind_resources",
40934                &self.max_per_stage_update_after_bind_resources,
40935            )
40936            .field(
40937                "max_descriptor_set_update_after_bind_samplers",
40938                &self.max_descriptor_set_update_after_bind_samplers,
40939            )
40940            .field(
40941                "max_descriptor_set_update_after_bind_uniform_buffers",
40942                &self.max_descriptor_set_update_after_bind_uniform_buffers,
40943            )
40944            .field(
40945                "max_descriptor_set_update_after_bind_uniform_buffers_dynamic",
40946                &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic,
40947            )
40948            .field(
40949                "max_descriptor_set_update_after_bind_storage_buffers",
40950                &self.max_descriptor_set_update_after_bind_storage_buffers,
40951            )
40952            .field(
40953                "max_descriptor_set_update_after_bind_storage_buffers_dynamic",
40954                &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic,
40955            )
40956            .field(
40957                "max_descriptor_set_update_after_bind_sampled_images",
40958                &self.max_descriptor_set_update_after_bind_sampled_images,
40959            )
40960            .field(
40961                "max_descriptor_set_update_after_bind_storage_images",
40962                &self.max_descriptor_set_update_after_bind_storage_images,
40963            )
40964            .field(
40965                "max_descriptor_set_update_after_bind_input_attachments",
40966                &self.max_descriptor_set_update_after_bind_input_attachments,
40967            )
40968            .field(
40969                "supported_depth_resolve_modes",
40970                &self.supported_depth_resolve_modes,
40971            )
40972            .field(
40973                "supported_stencil_resolve_modes",
40974                &self.supported_stencil_resolve_modes,
40975            )
40976            .field("independent_resolve_none", &self.independent_resolve_none)
40977            .field("independent_resolve", &self.independent_resolve)
40978            .field(
40979                "filter_minmax_single_component_formats",
40980                &self.filter_minmax_single_component_formats,
40981            )
40982            .field(
40983                "filter_minmax_image_component_mapping",
40984                &self.filter_minmax_image_component_mapping,
40985            )
40986            .field(
40987                "max_timeline_semaphore_value_difference",
40988                &self.max_timeline_semaphore_value_difference,
40989            )
40990            .field(
40991                "framebuffer_integer_color_sample_counts",
40992                &self.framebuffer_integer_color_sample_counts,
40993            )
40994            .finish()
40995    }
40996}
40997impl ::std::default::Default for PhysicalDeviceVulkan12Properties {
40998    fn default() -> Self {
40999        Self {
41000            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
41001            p_next: ::std::ptr::null_mut(),
41002            driver_id: DriverId::default(),
41003            driver_name: unsafe { ::std::mem::zeroed() },
41004            driver_info: unsafe { ::std::mem::zeroed() },
41005            conformance_version: ConformanceVersion::default(),
41006            denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
41007            rounding_mode_independence: ShaderFloatControlsIndependence::default(),
41008            shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
41009            shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
41010            shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
41011            shader_denorm_preserve_float16: Bool32::default(),
41012            shader_denorm_preserve_float32: Bool32::default(),
41013            shader_denorm_preserve_float64: Bool32::default(),
41014            shader_denorm_flush_to_zero_float16: Bool32::default(),
41015            shader_denorm_flush_to_zero_float32: Bool32::default(),
41016            shader_denorm_flush_to_zero_float64: Bool32::default(),
41017            shader_rounding_mode_rte_float16: Bool32::default(),
41018            shader_rounding_mode_rte_float32: Bool32::default(),
41019            shader_rounding_mode_rte_float64: Bool32::default(),
41020            shader_rounding_mode_rtz_float16: Bool32::default(),
41021            shader_rounding_mode_rtz_float32: Bool32::default(),
41022            shader_rounding_mode_rtz_float64: Bool32::default(),
41023            max_update_after_bind_descriptors_in_all_pools: u32::default(),
41024            shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
41025            shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
41026            shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
41027            shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
41028            shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
41029            robust_buffer_access_update_after_bind: Bool32::default(),
41030            quad_divergent_implicit_lod: Bool32::default(),
41031            max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
41032            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
41033            max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
41034            max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
41035            max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
41036            max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
41037            max_per_stage_update_after_bind_resources: u32::default(),
41038            max_descriptor_set_update_after_bind_samplers: u32::default(),
41039            max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
41040            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
41041            max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
41042            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
41043            max_descriptor_set_update_after_bind_sampled_images: u32::default(),
41044            max_descriptor_set_update_after_bind_storage_images: u32::default(),
41045            max_descriptor_set_update_after_bind_input_attachments: u32::default(),
41046            supported_depth_resolve_modes: ResolveModeFlags::default(),
41047            supported_stencil_resolve_modes: ResolveModeFlags::default(),
41048            independent_resolve_none: Bool32::default(),
41049            independent_resolve: Bool32::default(),
41050            filter_minmax_single_component_formats: Bool32::default(),
41051            filter_minmax_image_component_mapping: Bool32::default(),
41052            max_timeline_semaphore_value_difference: u64::default(),
41053            framebuffer_integer_color_sample_counts: SampleCountFlags::default(),
41054        }
41055    }
41056}
41057impl PhysicalDeviceVulkan12Properties {
41058    pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41059        PhysicalDeviceVulkan12PropertiesBuilder {
41060            inner: Self::default(),
41061            marker: ::std::marker::PhantomData,
41062        }
41063    }
41064}
41065#[repr(transparent)]
41066pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41067    inner: PhysicalDeviceVulkan12Properties,
41068    marker: ::std::marker::PhantomData<&'a ()>,
41069}
41070unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {}
41071unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {}
41072impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41073    type Target = PhysicalDeviceVulkan12Properties;
41074    fn deref(&self) -> &Self::Target {
41075        &self.inner
41076    }
41077}
41078impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41079    fn deref_mut(&mut self) -> &mut Self::Target {
41080        &mut self.inner
41081    }
41082}
41083impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
41084    pub fn driver_id(mut self, driver_id: DriverId) -> Self {
41085        self.inner.driver_id = driver_id;
41086        self
41087    }
41088    pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
41089        self.inner.driver_name = driver_name;
41090        self
41091    }
41092    pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
41093        self.inner.driver_info = driver_info;
41094        self
41095    }
41096    pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
41097        self.inner.conformance_version = conformance_version;
41098        self
41099    }
41100    pub fn denorm_behavior_independence(
41101        mut self,
41102        denorm_behavior_independence: ShaderFloatControlsIndependence,
41103    ) -> Self {
41104        self.inner.denorm_behavior_independence = denorm_behavior_independence;
41105        self
41106    }
41107    pub fn rounding_mode_independence(
41108        mut self,
41109        rounding_mode_independence: ShaderFloatControlsIndependence,
41110    ) -> Self {
41111        self.inner.rounding_mode_independence = rounding_mode_independence;
41112        self
41113    }
41114    pub fn shader_signed_zero_inf_nan_preserve_float16(
41115        mut self,
41116        shader_signed_zero_inf_nan_preserve_float16: bool,
41117    ) -> Self {
41118        self.inner.shader_signed_zero_inf_nan_preserve_float16 =
41119            shader_signed_zero_inf_nan_preserve_float16.into();
41120        self
41121    }
41122    pub fn shader_signed_zero_inf_nan_preserve_float32(
41123        mut self,
41124        shader_signed_zero_inf_nan_preserve_float32: bool,
41125    ) -> Self {
41126        self.inner.shader_signed_zero_inf_nan_preserve_float32 =
41127            shader_signed_zero_inf_nan_preserve_float32.into();
41128        self
41129    }
41130    pub fn shader_signed_zero_inf_nan_preserve_float64(
41131        mut self,
41132        shader_signed_zero_inf_nan_preserve_float64: bool,
41133    ) -> Self {
41134        self.inner.shader_signed_zero_inf_nan_preserve_float64 =
41135            shader_signed_zero_inf_nan_preserve_float64.into();
41136        self
41137    }
41138    pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
41139        self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
41140        self
41141    }
41142    pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
41143        self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
41144        self
41145    }
41146    pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
41147        self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
41148        self
41149    }
41150    pub fn shader_denorm_flush_to_zero_float16(
41151        mut self,
41152        shader_denorm_flush_to_zero_float16: bool,
41153    ) -> Self {
41154        self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
41155        self
41156    }
41157    pub fn shader_denorm_flush_to_zero_float32(
41158        mut self,
41159        shader_denorm_flush_to_zero_float32: bool,
41160    ) -> Self {
41161        self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
41162        self
41163    }
41164    pub fn shader_denorm_flush_to_zero_float64(
41165        mut self,
41166        shader_denorm_flush_to_zero_float64: bool,
41167    ) -> Self {
41168        self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
41169        self
41170    }
41171    pub fn shader_rounding_mode_rte_float16(
41172        mut self,
41173        shader_rounding_mode_rte_float16: bool,
41174    ) -> Self {
41175        self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
41176        self
41177    }
41178    pub fn shader_rounding_mode_rte_float32(
41179        mut self,
41180        shader_rounding_mode_rte_float32: bool,
41181    ) -> Self {
41182        self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
41183        self
41184    }
41185    pub fn shader_rounding_mode_rte_float64(
41186        mut self,
41187        shader_rounding_mode_rte_float64: bool,
41188    ) -> Self {
41189        self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
41190        self
41191    }
41192    pub fn shader_rounding_mode_rtz_float16(
41193        mut self,
41194        shader_rounding_mode_rtz_float16: bool,
41195    ) -> Self {
41196        self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
41197        self
41198    }
41199    pub fn shader_rounding_mode_rtz_float32(
41200        mut self,
41201        shader_rounding_mode_rtz_float32: bool,
41202    ) -> Self {
41203        self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
41204        self
41205    }
41206    pub fn shader_rounding_mode_rtz_float64(
41207        mut self,
41208        shader_rounding_mode_rtz_float64: bool,
41209    ) -> Self {
41210        self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
41211        self
41212    }
41213    pub fn max_update_after_bind_descriptors_in_all_pools(
41214        mut self,
41215        max_update_after_bind_descriptors_in_all_pools: u32,
41216    ) -> Self {
41217        self.inner.max_update_after_bind_descriptors_in_all_pools =
41218            max_update_after_bind_descriptors_in_all_pools;
41219        self
41220    }
41221    pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
41222        mut self,
41223        shader_uniform_buffer_array_non_uniform_indexing_native: bool,
41224    ) -> Self {
41225        self.inner
41226            .shader_uniform_buffer_array_non_uniform_indexing_native =
41227            shader_uniform_buffer_array_non_uniform_indexing_native.into();
41228        self
41229    }
41230    pub fn shader_sampled_image_array_non_uniform_indexing_native(
41231        mut self,
41232        shader_sampled_image_array_non_uniform_indexing_native: bool,
41233    ) -> Self {
41234        self.inner
41235            .shader_sampled_image_array_non_uniform_indexing_native =
41236            shader_sampled_image_array_non_uniform_indexing_native.into();
41237        self
41238    }
41239    pub fn shader_storage_buffer_array_non_uniform_indexing_native(
41240        mut self,
41241        shader_storage_buffer_array_non_uniform_indexing_native: bool,
41242    ) -> Self {
41243        self.inner
41244            .shader_storage_buffer_array_non_uniform_indexing_native =
41245            shader_storage_buffer_array_non_uniform_indexing_native.into();
41246        self
41247    }
41248    pub fn shader_storage_image_array_non_uniform_indexing_native(
41249        mut self,
41250        shader_storage_image_array_non_uniform_indexing_native: bool,
41251    ) -> Self {
41252        self.inner
41253            .shader_storage_image_array_non_uniform_indexing_native =
41254            shader_storage_image_array_non_uniform_indexing_native.into();
41255        self
41256    }
41257    pub fn shader_input_attachment_array_non_uniform_indexing_native(
41258        mut self,
41259        shader_input_attachment_array_non_uniform_indexing_native: bool,
41260    ) -> Self {
41261        self.inner
41262            .shader_input_attachment_array_non_uniform_indexing_native =
41263            shader_input_attachment_array_non_uniform_indexing_native.into();
41264        self
41265    }
41266    pub fn robust_buffer_access_update_after_bind(
41267        mut self,
41268        robust_buffer_access_update_after_bind: bool,
41269    ) -> Self {
41270        self.inner.robust_buffer_access_update_after_bind =
41271            robust_buffer_access_update_after_bind.into();
41272        self
41273    }
41274    pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
41275        self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
41276        self
41277    }
41278    pub fn max_per_stage_descriptor_update_after_bind_samplers(
41279        mut self,
41280        max_per_stage_descriptor_update_after_bind_samplers: u32,
41281    ) -> Self {
41282        self.inner
41283            .max_per_stage_descriptor_update_after_bind_samplers =
41284            max_per_stage_descriptor_update_after_bind_samplers;
41285        self
41286    }
41287    pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
41288        mut self,
41289        max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
41290    ) -> Self {
41291        self.inner
41292            .max_per_stage_descriptor_update_after_bind_uniform_buffers =
41293            max_per_stage_descriptor_update_after_bind_uniform_buffers;
41294        self
41295    }
41296    pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
41297        mut self,
41298        max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
41299    ) -> Self {
41300        self.inner
41301            .max_per_stage_descriptor_update_after_bind_storage_buffers =
41302            max_per_stage_descriptor_update_after_bind_storage_buffers;
41303        self
41304    }
41305    pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
41306        mut self,
41307        max_per_stage_descriptor_update_after_bind_sampled_images: u32,
41308    ) -> Self {
41309        self.inner
41310            .max_per_stage_descriptor_update_after_bind_sampled_images =
41311            max_per_stage_descriptor_update_after_bind_sampled_images;
41312        self
41313    }
41314    pub fn max_per_stage_descriptor_update_after_bind_storage_images(
41315        mut self,
41316        max_per_stage_descriptor_update_after_bind_storage_images: u32,
41317    ) -> Self {
41318        self.inner
41319            .max_per_stage_descriptor_update_after_bind_storage_images =
41320            max_per_stage_descriptor_update_after_bind_storage_images;
41321        self
41322    }
41323    pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
41324        mut self,
41325        max_per_stage_descriptor_update_after_bind_input_attachments: u32,
41326    ) -> Self {
41327        self.inner
41328            .max_per_stage_descriptor_update_after_bind_input_attachments =
41329            max_per_stage_descriptor_update_after_bind_input_attachments;
41330        self
41331    }
41332    pub fn max_per_stage_update_after_bind_resources(
41333        mut self,
41334        max_per_stage_update_after_bind_resources: u32,
41335    ) -> Self {
41336        self.inner.max_per_stage_update_after_bind_resources =
41337            max_per_stage_update_after_bind_resources;
41338        self
41339    }
41340    pub fn max_descriptor_set_update_after_bind_samplers(
41341        mut self,
41342        max_descriptor_set_update_after_bind_samplers: u32,
41343    ) -> Self {
41344        self.inner.max_descriptor_set_update_after_bind_samplers =
41345            max_descriptor_set_update_after_bind_samplers;
41346        self
41347    }
41348    pub fn max_descriptor_set_update_after_bind_uniform_buffers(
41349        mut self,
41350        max_descriptor_set_update_after_bind_uniform_buffers: u32,
41351    ) -> Self {
41352        self.inner
41353            .max_descriptor_set_update_after_bind_uniform_buffers =
41354            max_descriptor_set_update_after_bind_uniform_buffers;
41355        self
41356    }
41357    pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
41358        mut self,
41359        max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
41360    ) -> Self {
41361        self.inner
41362            .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
41363            max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
41364        self
41365    }
41366    pub fn max_descriptor_set_update_after_bind_storage_buffers(
41367        mut self,
41368        max_descriptor_set_update_after_bind_storage_buffers: u32,
41369    ) -> Self {
41370        self.inner
41371            .max_descriptor_set_update_after_bind_storage_buffers =
41372            max_descriptor_set_update_after_bind_storage_buffers;
41373        self
41374    }
41375    pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
41376        mut self,
41377        max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
41378    ) -> Self {
41379        self.inner
41380            .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
41381            max_descriptor_set_update_after_bind_storage_buffers_dynamic;
41382        self
41383    }
41384    pub fn max_descriptor_set_update_after_bind_sampled_images(
41385        mut self,
41386        max_descriptor_set_update_after_bind_sampled_images: u32,
41387    ) -> Self {
41388        self.inner
41389            .max_descriptor_set_update_after_bind_sampled_images =
41390            max_descriptor_set_update_after_bind_sampled_images;
41391        self
41392    }
41393    pub fn max_descriptor_set_update_after_bind_storage_images(
41394        mut self,
41395        max_descriptor_set_update_after_bind_storage_images: u32,
41396    ) -> Self {
41397        self.inner
41398            .max_descriptor_set_update_after_bind_storage_images =
41399            max_descriptor_set_update_after_bind_storage_images;
41400        self
41401    }
41402    pub fn max_descriptor_set_update_after_bind_input_attachments(
41403        mut self,
41404        max_descriptor_set_update_after_bind_input_attachments: u32,
41405    ) -> Self {
41406        self.inner
41407            .max_descriptor_set_update_after_bind_input_attachments =
41408            max_descriptor_set_update_after_bind_input_attachments;
41409        self
41410    }
41411    pub fn supported_depth_resolve_modes(
41412        mut self,
41413        supported_depth_resolve_modes: ResolveModeFlags,
41414    ) -> Self {
41415        self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
41416        self
41417    }
41418    pub fn supported_stencil_resolve_modes(
41419        mut self,
41420        supported_stencil_resolve_modes: ResolveModeFlags,
41421    ) -> Self {
41422        self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
41423        self
41424    }
41425    pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
41426        self.inner.independent_resolve_none = independent_resolve_none.into();
41427        self
41428    }
41429    pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
41430        self.inner.independent_resolve = independent_resolve.into();
41431        self
41432    }
41433    pub fn filter_minmax_single_component_formats(
41434        mut self,
41435        filter_minmax_single_component_formats: bool,
41436    ) -> Self {
41437        self.inner.filter_minmax_single_component_formats =
41438            filter_minmax_single_component_formats.into();
41439        self
41440    }
41441    pub fn filter_minmax_image_component_mapping(
41442        mut self,
41443        filter_minmax_image_component_mapping: bool,
41444    ) -> Self {
41445        self.inner.filter_minmax_image_component_mapping =
41446            filter_minmax_image_component_mapping.into();
41447        self
41448    }
41449    pub fn max_timeline_semaphore_value_difference(
41450        mut self,
41451        max_timeline_semaphore_value_difference: u64,
41452    ) -> Self {
41453        self.inner.max_timeline_semaphore_value_difference =
41454            max_timeline_semaphore_value_difference;
41455        self
41456    }
41457    pub fn framebuffer_integer_color_sample_counts(
41458        mut self,
41459        framebuffer_integer_color_sample_counts: SampleCountFlags,
41460    ) -> Self {
41461        self.inner.framebuffer_integer_color_sample_counts =
41462            framebuffer_integer_color_sample_counts;
41463        self
41464    }
41465    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41466    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41467    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
41468    pub fn build(self) -> PhysicalDeviceVulkan12Properties {
41469        self.inner
41470    }
41471}
41472#[repr(C)]
41473#[cfg_attr(feature = "debug", derive(Debug))]
41474#[derive(Copy, Clone)]
41475#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Features.html>"]
41476pub struct PhysicalDeviceVulkan13Features {
41477    pub s_type: StructureType,
41478    pub p_next: *mut c_void,
41479    pub robust_image_access: Bool32,
41480    pub inline_uniform_block: Bool32,
41481    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
41482    pub pipeline_creation_cache_control: Bool32,
41483    pub private_data: Bool32,
41484    pub shader_demote_to_helper_invocation: Bool32,
41485    pub shader_terminate_invocation: Bool32,
41486    pub subgroup_size_control: Bool32,
41487    pub compute_full_subgroups: Bool32,
41488    pub synchronization2: Bool32,
41489    pub texture_compression_astc_hdr: Bool32,
41490    pub shader_zero_initialize_workgroup_memory: Bool32,
41491    pub dynamic_rendering: Bool32,
41492    pub shader_integer_dot_product: Bool32,
41493    pub maintenance4: Bool32,
41494}
41495impl ::std::default::Default for PhysicalDeviceVulkan13Features {
41496    fn default() -> Self {
41497        Self {
41498            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
41499            p_next: ::std::ptr::null_mut(),
41500            robust_image_access: Bool32::default(),
41501            inline_uniform_block: Bool32::default(),
41502            descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
41503            pipeline_creation_cache_control: Bool32::default(),
41504            private_data: Bool32::default(),
41505            shader_demote_to_helper_invocation: Bool32::default(),
41506            shader_terminate_invocation: Bool32::default(),
41507            subgroup_size_control: Bool32::default(),
41508            compute_full_subgroups: Bool32::default(),
41509            synchronization2: Bool32::default(),
41510            texture_compression_astc_hdr: Bool32::default(),
41511            shader_zero_initialize_workgroup_memory: Bool32::default(),
41512            dynamic_rendering: Bool32::default(),
41513            shader_integer_dot_product: Bool32::default(),
41514            maintenance4: Bool32::default(),
41515        }
41516    }
41517}
41518impl PhysicalDeviceVulkan13Features {
41519    pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41520        PhysicalDeviceVulkan13FeaturesBuilder {
41521            inner: Self::default(),
41522            marker: ::std::marker::PhantomData,
41523        }
41524    }
41525}
41526#[repr(transparent)]
41527pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41528    inner: PhysicalDeviceVulkan13Features,
41529    marker: ::std::marker::PhantomData<&'a ()>,
41530}
41531unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
41532unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features {}
41533unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
41534unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features {}
41535impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41536    type Target = PhysicalDeviceVulkan13Features;
41537    fn deref(&self) -> &Self::Target {
41538        &self.inner
41539    }
41540}
41541impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41542    fn deref_mut(&mut self) -> &mut Self::Target {
41543        &mut self.inner
41544    }
41545}
41546impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
41547    pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
41548        self.inner.robust_image_access = robust_image_access.into();
41549        self
41550    }
41551    pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
41552        self.inner.inline_uniform_block = inline_uniform_block.into();
41553        self
41554    }
41555    pub fn descriptor_binding_inline_uniform_block_update_after_bind(
41556        mut self,
41557        descriptor_binding_inline_uniform_block_update_after_bind: bool,
41558    ) -> Self {
41559        self.inner
41560            .descriptor_binding_inline_uniform_block_update_after_bind =
41561            descriptor_binding_inline_uniform_block_update_after_bind.into();
41562        self
41563    }
41564    pub fn pipeline_creation_cache_control(
41565        mut self,
41566        pipeline_creation_cache_control: bool,
41567    ) -> Self {
41568        self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
41569        self
41570    }
41571    pub fn private_data(mut self, private_data: bool) -> Self {
41572        self.inner.private_data = private_data.into();
41573        self
41574    }
41575    pub fn shader_demote_to_helper_invocation(
41576        mut self,
41577        shader_demote_to_helper_invocation: bool,
41578    ) -> Self {
41579        self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
41580        self
41581    }
41582    pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
41583        self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
41584        self
41585    }
41586    pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
41587        self.inner.subgroup_size_control = subgroup_size_control.into();
41588        self
41589    }
41590    pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
41591        self.inner.compute_full_subgroups = compute_full_subgroups.into();
41592        self
41593    }
41594    pub fn synchronization2(mut self, synchronization2: bool) -> Self {
41595        self.inner.synchronization2 = synchronization2.into();
41596        self
41597    }
41598    pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
41599        self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
41600        self
41601    }
41602    pub fn shader_zero_initialize_workgroup_memory(
41603        mut self,
41604        shader_zero_initialize_workgroup_memory: bool,
41605    ) -> Self {
41606        self.inner.shader_zero_initialize_workgroup_memory =
41607            shader_zero_initialize_workgroup_memory.into();
41608        self
41609    }
41610    pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
41611        self.inner.dynamic_rendering = dynamic_rendering.into();
41612        self
41613    }
41614    pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
41615        self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
41616        self
41617    }
41618    pub fn maintenance4(mut self, maintenance4: bool) -> Self {
41619        self.inner.maintenance4 = maintenance4.into();
41620        self
41621    }
41622    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41623    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41624    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
41625    pub fn build(self) -> PhysicalDeviceVulkan13Features {
41626        self.inner
41627    }
41628}
41629#[repr(C)]
41630#[cfg_attr(feature = "debug", derive(Debug))]
41631#[derive(Copy, Clone)]
41632#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Properties.html>"]
41633pub struct PhysicalDeviceVulkan13Properties {
41634    pub s_type: StructureType,
41635    pub p_next: *mut c_void,
41636    pub min_subgroup_size: u32,
41637    pub max_subgroup_size: u32,
41638    pub max_compute_workgroup_subgroups: u32,
41639    pub required_subgroup_size_stages: ShaderStageFlags,
41640    pub max_inline_uniform_block_size: u32,
41641    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
41642    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
41643    pub max_descriptor_set_inline_uniform_blocks: u32,
41644    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
41645    pub max_inline_uniform_total_size: u32,
41646    pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
41647    pub integer_dot_product8_bit_signed_accelerated: Bool32,
41648    pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
41649    pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
41650    pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
41651    pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
41652    pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
41653    pub integer_dot_product16_bit_signed_accelerated: Bool32,
41654    pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
41655    pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
41656    pub integer_dot_product32_bit_signed_accelerated: Bool32,
41657    pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
41658    pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
41659    pub integer_dot_product64_bit_signed_accelerated: Bool32,
41660    pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
41661    pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
41662    pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
41663    pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
41664    pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
41665    pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
41666    pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
41667        Bool32,
41668    pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
41669    pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
41670    pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
41671    pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
41672    pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
41673    pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
41674    pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
41675    pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
41676    pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
41677    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
41678    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
41679    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
41680    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
41681    pub max_buffer_size: DeviceSize,
41682}
41683impl ::std::default::Default for PhysicalDeviceVulkan13Properties {
41684    fn default() -> Self {
41685        Self { s_type : StructureType :: PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES , p_next : :: std :: ptr :: null_mut () , min_subgroup_size : u32 :: default () , max_subgroup_size : u32 :: default () , max_compute_workgroup_subgroups : u32 :: default () , required_subgroup_size_stages : ShaderStageFlags :: default () , max_inline_uniform_block_size : u32 :: default () , max_per_stage_descriptor_inline_uniform_blocks : u32 :: default () , max_per_stage_descriptor_update_after_bind_inline_uniform_blocks : u32 :: default () , max_descriptor_set_inline_uniform_blocks : u32 :: default () , max_descriptor_set_update_after_bind_inline_uniform_blocks : u32 :: default () , max_inline_uniform_total_size : u32 :: default () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , storage_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , storage_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , uniform_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , uniform_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , max_buffer_size : DeviceSize :: default () }
41686    }
41687}
41688impl PhysicalDeviceVulkan13Properties {
41689    pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41690        PhysicalDeviceVulkan13PropertiesBuilder {
41691            inner: Self::default(),
41692            marker: ::std::marker::PhantomData,
41693        }
41694    }
41695}
41696#[repr(transparent)]
41697pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41698    inner: PhysicalDeviceVulkan13Properties,
41699    marker: ::std::marker::PhantomData<&'a ()>,
41700}
41701unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13PropertiesBuilder<'_> {}
41702unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties {}
41703impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41704    type Target = PhysicalDeviceVulkan13Properties;
41705    fn deref(&self) -> &Self::Target {
41706        &self.inner
41707    }
41708}
41709impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41710    fn deref_mut(&mut self) -> &mut Self::Target {
41711        &mut self.inner
41712    }
41713}
41714impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
41715    pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
41716        self.inner.min_subgroup_size = min_subgroup_size;
41717        self
41718    }
41719    pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
41720        self.inner.max_subgroup_size = max_subgroup_size;
41721        self
41722    }
41723    pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
41724        self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
41725        self
41726    }
41727    pub fn required_subgroup_size_stages(
41728        mut self,
41729        required_subgroup_size_stages: ShaderStageFlags,
41730    ) -> Self {
41731        self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
41732        self
41733    }
41734    pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
41735        self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
41736        self
41737    }
41738    pub fn max_per_stage_descriptor_inline_uniform_blocks(
41739        mut self,
41740        max_per_stage_descriptor_inline_uniform_blocks: u32,
41741    ) -> Self {
41742        self.inner.max_per_stage_descriptor_inline_uniform_blocks =
41743            max_per_stage_descriptor_inline_uniform_blocks;
41744        self
41745    }
41746    pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
41747        mut self,
41748        max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
41749    ) -> Self {
41750        self.inner
41751            .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
41752            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
41753        self
41754    }
41755    pub fn max_descriptor_set_inline_uniform_blocks(
41756        mut self,
41757        max_descriptor_set_inline_uniform_blocks: u32,
41758    ) -> Self {
41759        self.inner.max_descriptor_set_inline_uniform_blocks =
41760            max_descriptor_set_inline_uniform_blocks;
41761        self
41762    }
41763    pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
41764        mut self,
41765        max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
41766    ) -> Self {
41767        self.inner
41768            .max_descriptor_set_update_after_bind_inline_uniform_blocks =
41769            max_descriptor_set_update_after_bind_inline_uniform_blocks;
41770        self
41771    }
41772    pub fn max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self {
41773        self.inner.max_inline_uniform_total_size = max_inline_uniform_total_size;
41774        self
41775    }
41776    pub fn integer_dot_product8_bit_unsigned_accelerated(
41777        mut self,
41778        integer_dot_product8_bit_unsigned_accelerated: bool,
41779    ) -> Self {
41780        self.inner.integer_dot_product8_bit_unsigned_accelerated =
41781            integer_dot_product8_bit_unsigned_accelerated.into();
41782        self
41783    }
41784    pub fn integer_dot_product8_bit_signed_accelerated(
41785        mut self,
41786        integer_dot_product8_bit_signed_accelerated: bool,
41787    ) -> Self {
41788        self.inner.integer_dot_product8_bit_signed_accelerated =
41789            integer_dot_product8_bit_signed_accelerated.into();
41790        self
41791    }
41792    pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
41793        mut self,
41794        integer_dot_product8_bit_mixed_signedness_accelerated: bool,
41795    ) -> Self {
41796        self.inner
41797            .integer_dot_product8_bit_mixed_signedness_accelerated =
41798            integer_dot_product8_bit_mixed_signedness_accelerated.into();
41799        self
41800    }
41801    pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
41802        mut self,
41803        integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
41804    ) -> Self {
41805        self.inner
41806            .integer_dot_product4x8_bit_packed_unsigned_accelerated =
41807            integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
41808        self
41809    }
41810    pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
41811        mut self,
41812        integer_dot_product4x8_bit_packed_signed_accelerated: bool,
41813    ) -> Self {
41814        self.inner
41815            .integer_dot_product4x8_bit_packed_signed_accelerated =
41816            integer_dot_product4x8_bit_packed_signed_accelerated.into();
41817        self
41818    }
41819    pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
41820        mut self,
41821        integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
41822    ) -> Self {
41823        self.inner
41824            .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated =
41825            integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
41826        self
41827    }
41828    pub fn integer_dot_product16_bit_unsigned_accelerated(
41829        mut self,
41830        integer_dot_product16_bit_unsigned_accelerated: bool,
41831    ) -> Self {
41832        self.inner.integer_dot_product16_bit_unsigned_accelerated =
41833            integer_dot_product16_bit_unsigned_accelerated.into();
41834        self
41835    }
41836    pub fn integer_dot_product16_bit_signed_accelerated(
41837        mut self,
41838        integer_dot_product16_bit_signed_accelerated: bool,
41839    ) -> Self {
41840        self.inner.integer_dot_product16_bit_signed_accelerated =
41841            integer_dot_product16_bit_signed_accelerated.into();
41842        self
41843    }
41844    pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
41845        mut self,
41846        integer_dot_product16_bit_mixed_signedness_accelerated: bool,
41847    ) -> Self {
41848        self.inner
41849            .integer_dot_product16_bit_mixed_signedness_accelerated =
41850            integer_dot_product16_bit_mixed_signedness_accelerated.into();
41851        self
41852    }
41853    pub fn integer_dot_product32_bit_unsigned_accelerated(
41854        mut self,
41855        integer_dot_product32_bit_unsigned_accelerated: bool,
41856    ) -> Self {
41857        self.inner.integer_dot_product32_bit_unsigned_accelerated =
41858            integer_dot_product32_bit_unsigned_accelerated.into();
41859        self
41860    }
41861    pub fn integer_dot_product32_bit_signed_accelerated(
41862        mut self,
41863        integer_dot_product32_bit_signed_accelerated: bool,
41864    ) -> Self {
41865        self.inner.integer_dot_product32_bit_signed_accelerated =
41866            integer_dot_product32_bit_signed_accelerated.into();
41867        self
41868    }
41869    pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
41870        mut self,
41871        integer_dot_product32_bit_mixed_signedness_accelerated: bool,
41872    ) -> Self {
41873        self.inner
41874            .integer_dot_product32_bit_mixed_signedness_accelerated =
41875            integer_dot_product32_bit_mixed_signedness_accelerated.into();
41876        self
41877    }
41878    pub fn integer_dot_product64_bit_unsigned_accelerated(
41879        mut self,
41880        integer_dot_product64_bit_unsigned_accelerated: bool,
41881    ) -> Self {
41882        self.inner.integer_dot_product64_bit_unsigned_accelerated =
41883            integer_dot_product64_bit_unsigned_accelerated.into();
41884        self
41885    }
41886    pub fn integer_dot_product64_bit_signed_accelerated(
41887        mut self,
41888        integer_dot_product64_bit_signed_accelerated: bool,
41889    ) -> Self {
41890        self.inner.integer_dot_product64_bit_signed_accelerated =
41891            integer_dot_product64_bit_signed_accelerated.into();
41892        self
41893    }
41894    pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
41895        mut self,
41896        integer_dot_product64_bit_mixed_signedness_accelerated: bool,
41897    ) -> Self {
41898        self.inner
41899            .integer_dot_product64_bit_mixed_signedness_accelerated =
41900            integer_dot_product64_bit_mixed_signedness_accelerated.into();
41901        self
41902    }
41903    pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
41904        mut self,
41905        integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
41906    ) -> Self {
41907        self.inner
41908            .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated =
41909            integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
41910        self
41911    }
41912    pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
41913        mut self,
41914        integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
41915    ) -> Self {
41916        self.inner
41917            .integer_dot_product_accumulating_saturating8_bit_signed_accelerated =
41918            integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
41919        self
41920    }
41921    pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
41922        mut self,
41923        integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
41924    ) -> Self {
41925        self.inner
41926            .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated =
41927            integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
41928        self
41929    }
41930    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
41931        mut self,
41932        integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
41933    ) -> Self {
41934        self.inner
41935            .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated =
41936            integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
41937        self
41938    }
41939    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
41940        mut self,
41941        integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
41942    ) -> Self {
41943        self.inner
41944            .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated =
41945            integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
41946        self
41947    }
41948    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
41949        mut self,
41950        integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
41951    ) -> Self {
41952        self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
41953        self
41954    }
41955    pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
41956        mut self,
41957        integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
41958    ) -> Self {
41959        self.inner
41960            .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated =
41961            integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
41962        self
41963    }
41964    pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
41965        mut self,
41966        integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
41967    ) -> Self {
41968        self.inner
41969            .integer_dot_product_accumulating_saturating16_bit_signed_accelerated =
41970            integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
41971        self
41972    }
41973    pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
41974        mut self,
41975        integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
41976    ) -> Self {
41977        self.inner
41978            .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated =
41979            integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
41980        self
41981    }
41982    pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
41983        mut self,
41984        integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
41985    ) -> Self {
41986        self.inner
41987            .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated =
41988            integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
41989        self
41990    }
41991    pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
41992        mut self,
41993        integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
41994    ) -> Self {
41995        self.inner
41996            .integer_dot_product_accumulating_saturating32_bit_signed_accelerated =
41997            integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
41998        self
41999    }
42000    pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
42001        mut self,
42002        integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
42003    ) -> Self {
42004        self.inner
42005            .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated =
42006            integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
42007        self
42008    }
42009    pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
42010        mut self,
42011        integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
42012    ) -> Self {
42013        self.inner
42014            .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated =
42015            integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
42016        self
42017    }
42018    pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
42019        mut self,
42020        integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
42021    ) -> Self {
42022        self.inner
42023            .integer_dot_product_accumulating_saturating64_bit_signed_accelerated =
42024            integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
42025        self
42026    }
42027    pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
42028        mut self,
42029        integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
42030    ) -> Self {
42031        self.inner
42032            .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated =
42033            integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into();
42034        self
42035    }
42036    pub fn storage_texel_buffer_offset_alignment_bytes(
42037        mut self,
42038        storage_texel_buffer_offset_alignment_bytes: DeviceSize,
42039    ) -> Self {
42040        self.inner.storage_texel_buffer_offset_alignment_bytes =
42041            storage_texel_buffer_offset_alignment_bytes;
42042        self
42043    }
42044    pub fn storage_texel_buffer_offset_single_texel_alignment(
42045        mut self,
42046        storage_texel_buffer_offset_single_texel_alignment: bool,
42047    ) -> Self {
42048        self.inner
42049            .storage_texel_buffer_offset_single_texel_alignment =
42050            storage_texel_buffer_offset_single_texel_alignment.into();
42051        self
42052    }
42053    pub fn uniform_texel_buffer_offset_alignment_bytes(
42054        mut self,
42055        uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
42056    ) -> Self {
42057        self.inner.uniform_texel_buffer_offset_alignment_bytes =
42058            uniform_texel_buffer_offset_alignment_bytes;
42059        self
42060    }
42061    pub fn uniform_texel_buffer_offset_single_texel_alignment(
42062        mut self,
42063        uniform_texel_buffer_offset_single_texel_alignment: bool,
42064    ) -> Self {
42065        self.inner
42066            .uniform_texel_buffer_offset_single_texel_alignment =
42067            uniform_texel_buffer_offset_single_texel_alignment.into();
42068        self
42069    }
42070    pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
42071        self.inner.max_buffer_size = max_buffer_size;
42072        self
42073    }
42074    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42075    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42076    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42077    pub fn build(self) -> PhysicalDeviceVulkan13Properties {
42078        self.inner
42079    }
42080}
42081#[repr(C)]
42082#[cfg_attr(feature = "debug", derive(Debug))]
42083#[derive(Copy, Clone)]
42084#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html>"]
42085pub struct PipelineCompilerControlCreateInfoAMD {
42086    pub s_type: StructureType,
42087    pub p_next: *const c_void,
42088    pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
42089}
42090impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD {
42091    fn default() -> Self {
42092        Self {
42093            s_type: StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
42094            p_next: ::std::ptr::null(),
42095            compiler_control_flags: PipelineCompilerControlFlagsAMD::default(),
42096        }
42097    }
42098}
42099impl PipelineCompilerControlCreateInfoAMD {
42100    pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42101        PipelineCompilerControlCreateInfoAMDBuilder {
42102            inner: Self::default(),
42103            marker: ::std::marker::PhantomData,
42104        }
42105    }
42106}
42107#[repr(transparent)]
42108pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42109    inner: PipelineCompilerControlCreateInfoAMD,
42110    marker: ::std::marker::PhantomData<&'a ()>,
42111}
42112unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
42113unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
42114unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
42115unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
42116impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42117    type Target = PipelineCompilerControlCreateInfoAMD;
42118    fn deref(&self) -> &Self::Target {
42119        &self.inner
42120    }
42121}
42122impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42123    fn deref_mut(&mut self) -> &mut Self::Target {
42124        &mut self.inner
42125    }
42126}
42127impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
42128    pub fn compiler_control_flags(
42129        mut self,
42130        compiler_control_flags: PipelineCompilerControlFlagsAMD,
42131    ) -> Self {
42132        self.inner.compiler_control_flags = compiler_control_flags;
42133        self
42134    }
42135    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42136    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42137    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42138    pub fn build(self) -> PipelineCompilerControlCreateInfoAMD {
42139        self.inner
42140    }
42141}
42142#[repr(C)]
42143#[cfg_attr(feature = "debug", derive(Debug))]
42144#[derive(Copy, Clone)]
42145#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>"]
42146pub struct PhysicalDeviceCoherentMemoryFeaturesAMD {
42147    pub s_type: StructureType,
42148    pub p_next: *mut c_void,
42149    pub device_coherent_memory: Bool32,
42150}
42151impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD {
42152    fn default() -> Self {
42153        Self {
42154            s_type: StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
42155            p_next: ::std::ptr::null_mut(),
42156            device_coherent_memory: Bool32::default(),
42157        }
42158    }
42159}
42160impl PhysicalDeviceCoherentMemoryFeaturesAMD {
42161    pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42162        PhysicalDeviceCoherentMemoryFeaturesAMDBuilder {
42163            inner: Self::default(),
42164            marker: ::std::marker::PhantomData,
42165        }
42166    }
42167}
42168#[repr(transparent)]
42169pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42170    inner: PhysicalDeviceCoherentMemoryFeaturesAMD,
42171    marker: ::std::marker::PhantomData<&'a ()>,
42172}
42173unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
42174unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD {}
42175unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
42176unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {}
42177impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42178    type Target = PhysicalDeviceCoherentMemoryFeaturesAMD;
42179    fn deref(&self) -> &Self::Target {
42180        &self.inner
42181    }
42182}
42183impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42184    fn deref_mut(&mut self) -> &mut Self::Target {
42185        &mut self.inner
42186    }
42187}
42188impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
42189    pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self {
42190        self.inner.device_coherent_memory = device_coherent_memory.into();
42191        self
42192    }
42193    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42194    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42195    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42196    pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD {
42197        self.inner
42198    }
42199}
42200#[repr(C)]
42201#[derive(Copy, Clone)]
42202#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceToolProperties.html>"]
42203pub struct PhysicalDeviceToolProperties {
42204    pub s_type: StructureType,
42205    pub p_next: *mut c_void,
42206    pub name: [c_char; MAX_EXTENSION_NAME_SIZE],
42207    pub version: [c_char; MAX_EXTENSION_NAME_SIZE],
42208    pub purposes: ToolPurposeFlags,
42209    pub description: [c_char; MAX_DESCRIPTION_SIZE],
42210    pub layer: [c_char; MAX_EXTENSION_NAME_SIZE],
42211}
42212#[cfg(feature = "debug")]
42213impl fmt::Debug for PhysicalDeviceToolProperties {
42214    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42215        fmt.debug_struct("PhysicalDeviceToolProperties")
42216            .field("s_type", &self.s_type)
42217            .field("p_next", &self.p_next)
42218            .field("name", &unsafe {
42219                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
42220            })
42221            .field("version", &unsafe {
42222                ::std::ffi::CStr::from_ptr(self.version.as_ptr())
42223            })
42224            .field("purposes", &self.purposes)
42225            .field("description", &unsafe {
42226                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
42227            })
42228            .field("layer", &unsafe {
42229                ::std::ffi::CStr::from_ptr(self.layer.as_ptr())
42230            })
42231            .finish()
42232    }
42233}
42234impl ::std::default::Default for PhysicalDeviceToolProperties {
42235    fn default() -> Self {
42236        Self {
42237            s_type: StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES,
42238            p_next: ::std::ptr::null_mut(),
42239            name: unsafe { ::std::mem::zeroed() },
42240            version: unsafe { ::std::mem::zeroed() },
42241            purposes: ToolPurposeFlags::default(),
42242            description: unsafe { ::std::mem::zeroed() },
42243            layer: unsafe { ::std::mem::zeroed() },
42244        }
42245    }
42246}
42247impl PhysicalDeviceToolProperties {
42248    pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> {
42249        PhysicalDeviceToolPropertiesBuilder {
42250            inner: Self::default(),
42251            marker: ::std::marker::PhantomData,
42252        }
42253    }
42254}
42255#[repr(transparent)]
42256pub struct PhysicalDeviceToolPropertiesBuilder<'a> {
42257    inner: PhysicalDeviceToolProperties,
42258    marker: ::std::marker::PhantomData<&'a ()>,
42259}
42260impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> {
42261    type Target = PhysicalDeviceToolProperties;
42262    fn deref(&self) -> &Self::Target {
42263        &self.inner
42264    }
42265}
42266impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> {
42267    fn deref_mut(&mut self) -> &mut Self::Target {
42268        &mut self.inner
42269    }
42270}
42271impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> {
42272    pub fn name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
42273        self.inner.name = name;
42274        self
42275    }
42276    pub fn version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
42277        self.inner.version = version;
42278        self
42279    }
42280    pub fn purposes(mut self, purposes: ToolPurposeFlags) -> Self {
42281        self.inner.purposes = purposes;
42282        self
42283    }
42284    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
42285        self.inner.description = description;
42286        self
42287    }
42288    pub fn layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
42289        self.inner.layer = layer;
42290        self
42291    }
42292    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42293    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42294    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42295    pub fn build(self) -> PhysicalDeviceToolProperties {
42296        self.inner
42297    }
42298}
42299#[repr(C)]
42300#[derive(Copy, Clone)]
42301#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html>"]
42302pub struct SamplerCustomBorderColorCreateInfoEXT {
42303    pub s_type: StructureType,
42304    pub p_next: *const c_void,
42305    pub custom_border_color: ClearColorValue,
42306    pub format: Format,
42307}
42308#[cfg(feature = "debug")]
42309impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT {
42310    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42311        fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT")
42312            .field("s_type", &self.s_type)
42313            .field("p_next", &self.p_next)
42314            .field("custom_border_color", &"union")
42315            .field("format", &self.format)
42316            .finish()
42317    }
42318}
42319impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT {
42320    fn default() -> Self {
42321        Self {
42322            s_type: StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
42323            p_next: ::std::ptr::null(),
42324            custom_border_color: ClearColorValue::default(),
42325            format: Format::default(),
42326        }
42327    }
42328}
42329impl SamplerCustomBorderColorCreateInfoEXT {
42330    pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42331        SamplerCustomBorderColorCreateInfoEXTBuilder {
42332            inner: Self::default(),
42333            marker: ::std::marker::PhantomData,
42334        }
42335    }
42336}
42337#[repr(transparent)]
42338pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42339    inner: SamplerCustomBorderColorCreateInfoEXT,
42340    marker: ::std::marker::PhantomData<&'a ()>,
42341}
42342unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {}
42343unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {}
42344impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42345    type Target = SamplerCustomBorderColorCreateInfoEXT;
42346    fn deref(&self) -> &Self::Target {
42347        &self.inner
42348    }
42349}
42350impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42351    fn deref_mut(&mut self) -> &mut Self::Target {
42352        &mut self.inner
42353    }
42354}
42355impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
42356    pub fn custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self {
42357        self.inner.custom_border_color = custom_border_color;
42358        self
42359    }
42360    pub fn format(mut self, format: Format) -> Self {
42361        self.inner.format = format;
42362        self
42363    }
42364    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42365    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42366    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42367    pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT {
42368        self.inner
42369    }
42370}
42371#[repr(C)]
42372#[cfg_attr(feature = "debug", derive(Debug))]
42373#[derive(Copy, Clone)]
42374#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html>"]
42375pub struct PhysicalDeviceCustomBorderColorPropertiesEXT {
42376    pub s_type: StructureType,
42377    pub p_next: *mut c_void,
42378    pub max_custom_border_color_samplers: u32,
42379}
42380impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT {
42381    fn default() -> Self {
42382        Self {
42383            s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
42384            p_next: ::std::ptr::null_mut(),
42385            max_custom_border_color_samplers: u32::default(),
42386        }
42387    }
42388}
42389impl PhysicalDeviceCustomBorderColorPropertiesEXT {
42390    pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42391        PhysicalDeviceCustomBorderColorPropertiesEXTBuilder {
42392            inner: Self::default(),
42393            marker: ::std::marker::PhantomData,
42394        }
42395    }
42396}
42397#[repr(transparent)]
42398pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42399    inner: PhysicalDeviceCustomBorderColorPropertiesEXT,
42400    marker: ::std::marker::PhantomData<&'a ()>,
42401}
42402unsafe impl ExtendsPhysicalDeviceProperties2
42403    for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_>
42404{
42405}
42406unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {}
42407impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42408    type Target = PhysicalDeviceCustomBorderColorPropertiesEXT;
42409    fn deref(&self) -> &Self::Target {
42410        &self.inner
42411    }
42412}
42413impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42414    fn deref_mut(&mut self) -> &mut Self::Target {
42415        &mut self.inner
42416    }
42417}
42418impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
42419    pub fn max_custom_border_color_samplers(
42420        mut self,
42421        max_custom_border_color_samplers: u32,
42422    ) -> Self {
42423        self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers;
42424        self
42425    }
42426    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42427    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42428    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42429    pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT {
42430        self.inner
42431    }
42432}
42433#[repr(C)]
42434#[cfg_attr(feature = "debug", derive(Debug))]
42435#[derive(Copy, Clone)]
42436#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html>"]
42437pub struct PhysicalDeviceCustomBorderColorFeaturesEXT {
42438    pub s_type: StructureType,
42439    pub p_next: *mut c_void,
42440    pub custom_border_colors: Bool32,
42441    pub custom_border_color_without_format: Bool32,
42442}
42443impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT {
42444    fn default() -> Self {
42445        Self {
42446            s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
42447            p_next: ::std::ptr::null_mut(),
42448            custom_border_colors: Bool32::default(),
42449            custom_border_color_without_format: Bool32::default(),
42450        }
42451    }
42452}
42453impl PhysicalDeviceCustomBorderColorFeaturesEXT {
42454    pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42455        PhysicalDeviceCustomBorderColorFeaturesEXTBuilder {
42456            inner: Self::default(),
42457            marker: ::std::marker::PhantomData,
42458        }
42459    }
42460}
42461#[repr(transparent)]
42462pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42463    inner: PhysicalDeviceCustomBorderColorFeaturesEXT,
42464    marker: ::std::marker::PhantomData<&'a ()>,
42465}
42466unsafe impl ExtendsPhysicalDeviceFeatures2
42467    for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_>
42468{
42469}
42470unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT {}
42471unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {}
42472unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {}
42473impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42474    type Target = PhysicalDeviceCustomBorderColorFeaturesEXT;
42475    fn deref(&self) -> &Self::Target {
42476        &self.inner
42477    }
42478}
42479impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42480    fn deref_mut(&mut self) -> &mut Self::Target {
42481        &mut self.inner
42482    }
42483}
42484impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
42485    pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self {
42486        self.inner.custom_border_colors = custom_border_colors.into();
42487        self
42488    }
42489    pub fn custom_border_color_without_format(
42490        mut self,
42491        custom_border_color_without_format: bool,
42492    ) -> Self {
42493        self.inner.custom_border_color_without_format = custom_border_color_without_format.into();
42494        self
42495    }
42496    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42497    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42498    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42499    pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT {
42500        self.inner
42501    }
42502}
42503#[repr(C)]
42504#[cfg_attr(feature = "debug", derive(Debug))]
42505#[derive(Copy, Clone)]
42506#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html>"]
42507pub struct SamplerBorderColorComponentMappingCreateInfoEXT {
42508    pub s_type: StructureType,
42509    pub p_next: *const c_void,
42510    pub components: ComponentMapping,
42511    pub srgb: Bool32,
42512}
42513impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT {
42514    fn default() -> Self {
42515        Self {
42516            s_type: StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
42517            p_next: ::std::ptr::null(),
42518            components: ComponentMapping::default(),
42519            srgb: Bool32::default(),
42520        }
42521    }
42522}
42523impl SamplerBorderColorComponentMappingCreateInfoEXT {
42524    pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42525        SamplerBorderColorComponentMappingCreateInfoEXTBuilder {
42526            inner: Self::default(),
42527            marker: ::std::marker::PhantomData,
42528        }
42529    }
42530}
42531#[repr(transparent)]
42532pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42533    inner: SamplerBorderColorComponentMappingCreateInfoEXT,
42534    marker: ::std::marker::PhantomData<&'a ()>,
42535}
42536unsafe impl ExtendsSamplerCreateInfo
42537    for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_>
42538{
42539}
42540unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {}
42541impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42542    type Target = SamplerBorderColorComponentMappingCreateInfoEXT;
42543    fn deref(&self) -> &Self::Target {
42544        &self.inner
42545    }
42546}
42547impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42548    fn deref_mut(&mut self) -> &mut Self::Target {
42549        &mut self.inner
42550    }
42551}
42552impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
42553    pub fn components(mut self, components: ComponentMapping) -> Self {
42554        self.inner.components = components;
42555        self
42556    }
42557    pub fn srgb(mut self, srgb: bool) -> Self {
42558        self.inner.srgb = srgb.into();
42559        self
42560    }
42561    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42562    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42563    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42564    pub fn build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT {
42565        self.inner
42566    }
42567}
42568#[repr(C)]
42569#[cfg_attr(feature = "debug", derive(Debug))]
42570#[derive(Copy, Clone)]
42571#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html>"]
42572pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42573    pub s_type: StructureType,
42574    pub p_next: *mut c_void,
42575    pub border_color_swizzle: Bool32,
42576    pub border_color_swizzle_from_image: Bool32,
42577}
42578impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42579    fn default() -> Self {
42580        Self {
42581            s_type: StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT,
42582            p_next: ::std::ptr::null_mut(),
42583            border_color_swizzle: Bool32::default(),
42584            border_color_swizzle_from_image: Bool32::default(),
42585        }
42586    }
42587}
42588impl PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42589    pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42590        PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder {
42591            inner: Self::default(),
42592            marker: ::std::marker::PhantomData,
42593        }
42594    }
42595}
42596#[repr(transparent)]
42597pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42598    inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT,
42599    marker: ::std::marker::PhantomData<&'a ()>,
42600}
42601unsafe impl ExtendsPhysicalDeviceFeatures2
42602    for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_>
42603{
42604}
42605unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
42606unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {}
42607unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
42608impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42609    type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
42610    fn deref(&self) -> &Self::Target {
42611        &self.inner
42612    }
42613}
42614impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42615    fn deref_mut(&mut self) -> &mut Self::Target {
42616        &mut self.inner
42617    }
42618}
42619impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
42620    pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self {
42621        self.inner.border_color_swizzle = border_color_swizzle.into();
42622        self
42623    }
42624    pub fn border_color_swizzle_from_image(
42625        mut self,
42626        border_color_swizzle_from_image: bool,
42627    ) -> Self {
42628        self.inner.border_color_swizzle_from_image = border_color_swizzle_from_image.into();
42629        self
42630    }
42631    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42632    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42633    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42634    pub fn build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT {
42635        self.inner
42636    }
42637}
42638#[repr(C)]
42639#[derive(Copy, Clone)]
42640#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressKHR.html>"]
42641pub union DeviceOrHostAddressKHR {
42642    pub device_address: DeviceAddress,
42643    pub host_address: *mut c_void,
42644}
42645impl ::std::default::Default for DeviceOrHostAddressKHR {
42646    fn default() -> Self {
42647        unsafe { ::std::mem::zeroed() }
42648    }
42649}
42650#[repr(C)]
42651#[derive(Copy, Clone)]
42652#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressConstKHR.html>"]
42653pub union DeviceOrHostAddressConstKHR {
42654    pub device_address: DeviceAddress,
42655    pub host_address: *const c_void,
42656}
42657impl ::std::default::Default for DeviceOrHostAddressConstKHR {
42658    fn default() -> Self {
42659        unsafe { ::std::mem::zeroed() }
42660    }
42661}
42662#[repr(C)]
42663#[derive(Copy, Clone)]
42664#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>"]
42665pub struct AccelerationStructureGeometryTrianglesDataKHR {
42666    pub s_type: StructureType,
42667    pub p_next: *const c_void,
42668    pub vertex_format: Format,
42669    pub vertex_data: DeviceOrHostAddressConstKHR,
42670    pub vertex_stride: DeviceSize,
42671    pub max_vertex: u32,
42672    pub index_type: IndexType,
42673    pub index_data: DeviceOrHostAddressConstKHR,
42674    pub transform_data: DeviceOrHostAddressConstKHR,
42675}
42676#[cfg(feature = "debug")]
42677impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR {
42678    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42679        fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR")
42680            .field("s_type", &self.s_type)
42681            .field("p_next", &self.p_next)
42682            .field("vertex_format", &self.vertex_format)
42683            .field("vertex_data", &"union")
42684            .field("vertex_stride", &self.vertex_stride)
42685            .field("max_vertex", &self.max_vertex)
42686            .field("index_type", &self.index_type)
42687            .field("index_data", &"union")
42688            .field("transform_data", &"union")
42689            .finish()
42690    }
42691}
42692impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR {
42693    fn default() -> Self {
42694        Self {
42695            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
42696            p_next: ::std::ptr::null(),
42697            vertex_format: Format::default(),
42698            vertex_data: DeviceOrHostAddressConstKHR::default(),
42699            vertex_stride: DeviceSize::default(),
42700            max_vertex: u32::default(),
42701            index_type: IndexType::default(),
42702            index_data: DeviceOrHostAddressConstKHR::default(),
42703            transform_data: DeviceOrHostAddressConstKHR::default(),
42704        }
42705    }
42706}
42707impl AccelerationStructureGeometryTrianglesDataKHR {
42708    pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42709        AccelerationStructureGeometryTrianglesDataKHRBuilder {
42710            inner: Self::default(),
42711            marker: ::std::marker::PhantomData,
42712        }
42713    }
42714}
42715#[repr(transparent)]
42716pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42717    inner: AccelerationStructureGeometryTrianglesDataKHR,
42718    marker: ::std::marker::PhantomData<&'a ()>,
42719}
42720pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {}
42721impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42722    type Target = AccelerationStructureGeometryTrianglesDataKHR;
42723    fn deref(&self) -> &Self::Target {
42724        &self.inner
42725    }
42726}
42727impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42728    fn deref_mut(&mut self) -> &mut Self::Target {
42729        &mut self.inner
42730    }
42731}
42732impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
42733    pub fn vertex_format(mut self, vertex_format: Format) -> Self {
42734        self.inner.vertex_format = vertex_format;
42735        self
42736    }
42737    pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
42738        self.inner.vertex_data = vertex_data;
42739        self
42740    }
42741    pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
42742        self.inner.vertex_stride = vertex_stride;
42743        self
42744    }
42745    pub fn max_vertex(mut self, max_vertex: u32) -> Self {
42746        self.inner.max_vertex = max_vertex;
42747        self
42748    }
42749    pub fn index_type(mut self, index_type: IndexType) -> Self {
42750        self.inner.index_type = index_type;
42751        self
42752    }
42753    pub fn index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self {
42754        self.inner.index_data = index_data;
42755        self
42756    }
42757    pub fn transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self {
42758        self.inner.transform_data = transform_data;
42759        self
42760    }
42761    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
42762    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
42763    #[doc = r" valid extension structs can be pushed into the chain."]
42764    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
42765    #[doc = r" chain will look like `A -> D -> B -> C`."]
42766    pub fn push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>(
42767        mut self,
42768        next: &'a mut T,
42769    ) -> Self {
42770        unsafe {
42771            let next_ptr = <*const T>::cast(next);
42772            let last_next = ptr_chain_iter(next).last().unwrap();
42773            (*last_next).p_next = self.inner.p_next as _;
42774            self.inner.p_next = next_ptr;
42775        }
42776        self
42777    }
42778    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42779    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42780    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42781    pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR {
42782        self.inner
42783    }
42784}
42785#[repr(C)]
42786#[derive(Copy, Clone)]
42787#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>"]
42788pub struct AccelerationStructureGeometryAabbsDataKHR {
42789    pub s_type: StructureType,
42790    pub p_next: *const c_void,
42791    pub data: DeviceOrHostAddressConstKHR,
42792    pub stride: DeviceSize,
42793}
42794#[cfg(feature = "debug")]
42795impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR {
42796    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42797        fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR")
42798            .field("s_type", &self.s_type)
42799            .field("p_next", &self.p_next)
42800            .field("data", &"union")
42801            .field("stride", &self.stride)
42802            .finish()
42803    }
42804}
42805impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR {
42806    fn default() -> Self {
42807        Self {
42808            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
42809            p_next: ::std::ptr::null(),
42810            data: DeviceOrHostAddressConstKHR::default(),
42811            stride: DeviceSize::default(),
42812        }
42813    }
42814}
42815impl AccelerationStructureGeometryAabbsDataKHR {
42816    pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42817        AccelerationStructureGeometryAabbsDataKHRBuilder {
42818            inner: Self::default(),
42819            marker: ::std::marker::PhantomData,
42820        }
42821    }
42822}
42823#[repr(transparent)]
42824pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42825    inner: AccelerationStructureGeometryAabbsDataKHR,
42826    marker: ::std::marker::PhantomData<&'a ()>,
42827}
42828impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42829    type Target = AccelerationStructureGeometryAabbsDataKHR;
42830    fn deref(&self) -> &Self::Target {
42831        &self.inner
42832    }
42833}
42834impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42835    fn deref_mut(&mut self) -> &mut Self::Target {
42836        &mut self.inner
42837    }
42838}
42839impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
42840    pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
42841        self.inner.data = data;
42842        self
42843    }
42844    pub fn stride(mut self, stride: DeviceSize) -> Self {
42845        self.inner.stride = stride;
42846        self
42847    }
42848    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42849    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42850    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42851    pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR {
42852        self.inner
42853    }
42854}
42855#[repr(C)]
42856#[derive(Copy, Clone)]
42857#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>"]
42858pub struct AccelerationStructureGeometryInstancesDataKHR {
42859    pub s_type: StructureType,
42860    pub p_next: *const c_void,
42861    pub array_of_pointers: Bool32,
42862    pub data: DeviceOrHostAddressConstKHR,
42863}
42864#[cfg(feature = "debug")]
42865impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR {
42866    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42867        fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR")
42868            .field("s_type", &self.s_type)
42869            .field("p_next", &self.p_next)
42870            .field("array_of_pointers", &self.array_of_pointers)
42871            .field("data", &"union")
42872            .finish()
42873    }
42874}
42875impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR {
42876    fn default() -> Self {
42877        Self {
42878            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
42879            p_next: ::std::ptr::null(),
42880            array_of_pointers: Bool32::default(),
42881            data: DeviceOrHostAddressConstKHR::default(),
42882        }
42883    }
42884}
42885impl AccelerationStructureGeometryInstancesDataKHR {
42886    pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42887        AccelerationStructureGeometryInstancesDataKHRBuilder {
42888            inner: Self::default(),
42889            marker: ::std::marker::PhantomData,
42890        }
42891    }
42892}
42893#[repr(transparent)]
42894pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42895    inner: AccelerationStructureGeometryInstancesDataKHR,
42896    marker: ::std::marker::PhantomData<&'a ()>,
42897}
42898impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42899    type Target = AccelerationStructureGeometryInstancesDataKHR;
42900    fn deref(&self) -> &Self::Target {
42901        &self.inner
42902    }
42903}
42904impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42905    fn deref_mut(&mut self) -> &mut Self::Target {
42906        &mut self.inner
42907    }
42908}
42909impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
42910    pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self {
42911        self.inner.array_of_pointers = array_of_pointers.into();
42912        self
42913    }
42914    pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
42915        self.inner.data = data;
42916        self
42917    }
42918    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42919    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42920    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
42921    pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR {
42922        self.inner
42923    }
42924}
42925#[repr(C)]
42926#[derive(Copy, Clone)]
42927#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html>"]
42928pub union AccelerationStructureGeometryDataKHR {
42929    pub triangles: AccelerationStructureGeometryTrianglesDataKHR,
42930    pub aabbs: AccelerationStructureGeometryAabbsDataKHR,
42931    pub instances: AccelerationStructureGeometryInstancesDataKHR,
42932}
42933impl ::std::default::Default for AccelerationStructureGeometryDataKHR {
42934    fn default() -> Self {
42935        unsafe { ::std::mem::zeroed() }
42936    }
42937}
42938#[repr(C)]
42939#[derive(Copy, Clone)]
42940#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryKHR.html>"]
42941pub struct AccelerationStructureGeometryKHR {
42942    pub s_type: StructureType,
42943    pub p_next: *const c_void,
42944    pub geometry_type: GeometryTypeKHR,
42945    pub geometry: AccelerationStructureGeometryDataKHR,
42946    pub flags: GeometryFlagsKHR,
42947}
42948#[cfg(feature = "debug")]
42949impl fmt::Debug for AccelerationStructureGeometryKHR {
42950    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
42951        fmt.debug_struct("AccelerationStructureGeometryKHR")
42952            .field("s_type", &self.s_type)
42953            .field("p_next", &self.p_next)
42954            .field("geometry_type", &self.geometry_type)
42955            .field("geometry", &"union")
42956            .field("flags", &self.flags)
42957            .finish()
42958    }
42959}
42960impl ::std::default::Default for AccelerationStructureGeometryKHR {
42961    fn default() -> Self {
42962        Self {
42963            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR,
42964            p_next: ::std::ptr::null(),
42965            geometry_type: GeometryTypeKHR::default(),
42966            geometry: AccelerationStructureGeometryDataKHR::default(),
42967            flags: GeometryFlagsKHR::default(),
42968        }
42969    }
42970}
42971impl AccelerationStructureGeometryKHR {
42972    pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> {
42973        AccelerationStructureGeometryKHRBuilder {
42974            inner: Self::default(),
42975            marker: ::std::marker::PhantomData,
42976        }
42977    }
42978}
42979#[repr(transparent)]
42980pub struct AccelerationStructureGeometryKHRBuilder<'a> {
42981    inner: AccelerationStructureGeometryKHR,
42982    marker: ::std::marker::PhantomData<&'a ()>,
42983}
42984impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> {
42985    type Target = AccelerationStructureGeometryKHR;
42986    fn deref(&self) -> &Self::Target {
42987        &self.inner
42988    }
42989}
42990impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> {
42991    fn deref_mut(&mut self) -> &mut Self::Target {
42992        &mut self.inner
42993    }
42994}
42995impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
42996    pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
42997        self.inner.geometry_type = geometry_type;
42998        self
42999    }
43000    pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self {
43001        self.inner.geometry = geometry;
43002        self
43003    }
43004    pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
43005        self.inner.flags = flags;
43006        self
43007    }
43008    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43009    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43010    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43011    pub fn build(self) -> AccelerationStructureGeometryKHR {
43012        self.inner
43013    }
43014}
43015#[repr(C)]
43016#[derive(Copy, Clone)]
43017#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>"]
43018pub struct AccelerationStructureBuildGeometryInfoKHR {
43019    pub s_type: StructureType,
43020    pub p_next: *const c_void,
43021    pub ty: AccelerationStructureTypeKHR,
43022    pub flags: BuildAccelerationStructureFlagsKHR,
43023    pub mode: BuildAccelerationStructureModeKHR,
43024    pub src_acceleration_structure: AccelerationStructureKHR,
43025    pub dst_acceleration_structure: AccelerationStructureKHR,
43026    pub geometry_count: u32,
43027    pub p_geometries: *const AccelerationStructureGeometryKHR,
43028    pub pp_geometries: *const *const AccelerationStructureGeometryKHR,
43029    pub scratch_data: DeviceOrHostAddressKHR,
43030}
43031#[cfg(feature = "debug")]
43032impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR {
43033    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43034        fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR")
43035            .field("s_type", &self.s_type)
43036            .field("p_next", &self.p_next)
43037            .field("ty", &self.ty)
43038            .field("flags", &self.flags)
43039            .field("mode", &self.mode)
43040            .field(
43041                "src_acceleration_structure",
43042                &self.src_acceleration_structure,
43043            )
43044            .field(
43045                "dst_acceleration_structure",
43046                &self.dst_acceleration_structure,
43047            )
43048            .field("geometry_count", &self.geometry_count)
43049            .field("p_geometries", &self.p_geometries)
43050            .field("pp_geometries", &self.pp_geometries)
43051            .field("scratch_data", &"union")
43052            .finish()
43053    }
43054}
43055impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR {
43056    fn default() -> Self {
43057        Self {
43058            s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
43059            p_next: ::std::ptr::null(),
43060            ty: AccelerationStructureTypeKHR::default(),
43061            flags: BuildAccelerationStructureFlagsKHR::default(),
43062            mode: BuildAccelerationStructureModeKHR::default(),
43063            src_acceleration_structure: AccelerationStructureKHR::default(),
43064            dst_acceleration_structure: AccelerationStructureKHR::default(),
43065            geometry_count: u32::default(),
43066            p_geometries: ::std::ptr::null(),
43067            pp_geometries: ::std::ptr::null(),
43068            scratch_data: DeviceOrHostAddressKHR::default(),
43069        }
43070    }
43071}
43072impl AccelerationStructureBuildGeometryInfoKHR {
43073    pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43074        AccelerationStructureBuildGeometryInfoKHRBuilder {
43075            inner: Self::default(),
43076            marker: ::std::marker::PhantomData,
43077        }
43078    }
43079}
43080#[repr(transparent)]
43081pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43082    inner: AccelerationStructureBuildGeometryInfoKHR,
43083    marker: ::std::marker::PhantomData<&'a ()>,
43084}
43085impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43086    type Target = AccelerationStructureBuildGeometryInfoKHR;
43087    fn deref(&self) -> &Self::Target {
43088        &self.inner
43089    }
43090}
43091impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43092    fn deref_mut(&mut self) -> &mut Self::Target {
43093        &mut self.inner
43094    }
43095}
43096impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
43097    pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
43098        self.inner.ty = ty;
43099        self
43100    }
43101    pub fn flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self {
43102        self.inner.flags = flags;
43103        self
43104    }
43105    pub fn mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self {
43106        self.inner.mode = mode;
43107        self
43108    }
43109    pub fn src_acceleration_structure(
43110        mut self,
43111        src_acceleration_structure: AccelerationStructureKHR,
43112    ) -> Self {
43113        self.inner.src_acceleration_structure = src_acceleration_structure;
43114        self
43115    }
43116    pub fn dst_acceleration_structure(
43117        mut self,
43118        dst_acceleration_structure: AccelerationStructureKHR,
43119    ) -> Self {
43120        self.inner.dst_acceleration_structure = dst_acceleration_structure;
43121        self
43122    }
43123    pub fn geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self {
43124        self.inner.geometry_count = geometries.len() as _;
43125        self.inner.p_geometries = geometries.as_ptr();
43126        self
43127    }
43128    pub fn geometries_ptrs(
43129        mut self,
43130        geometries: &'a [&'a AccelerationStructureGeometryKHR],
43131    ) -> Self {
43132        self.inner.geometry_count = geometries.len() as _;
43133        self.inner.pp_geometries = geometries.as_ptr() as *const *const _;
43134        self
43135    }
43136    pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self {
43137        self.inner.scratch_data = scratch_data;
43138        self
43139    }
43140    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43141    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43142    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43143    pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR {
43144        self.inner
43145    }
43146}
43147#[repr(C)]
43148#[cfg_attr(feature = "debug", derive(Debug))]
43149#[derive(Copy, Clone, Default)]
43150#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildRangeInfoKHR.html>"]
43151pub struct AccelerationStructureBuildRangeInfoKHR {
43152    pub primitive_count: u32,
43153    pub primitive_offset: u32,
43154    pub first_vertex: u32,
43155    pub transform_offset: u32,
43156}
43157impl AccelerationStructureBuildRangeInfoKHR {
43158    pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43159        AccelerationStructureBuildRangeInfoKHRBuilder {
43160            inner: Self::default(),
43161            marker: ::std::marker::PhantomData,
43162        }
43163    }
43164}
43165#[repr(transparent)]
43166pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43167    inner: AccelerationStructureBuildRangeInfoKHR,
43168    marker: ::std::marker::PhantomData<&'a ()>,
43169}
43170impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43171    type Target = AccelerationStructureBuildRangeInfoKHR;
43172    fn deref(&self) -> &Self::Target {
43173        &self.inner
43174    }
43175}
43176impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43177    fn deref_mut(&mut self) -> &mut Self::Target {
43178        &mut self.inner
43179    }
43180}
43181impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
43182    pub fn primitive_count(mut self, primitive_count: u32) -> Self {
43183        self.inner.primitive_count = primitive_count;
43184        self
43185    }
43186    pub fn primitive_offset(mut self, primitive_offset: u32) -> Self {
43187        self.inner.primitive_offset = primitive_offset;
43188        self
43189    }
43190    pub fn first_vertex(mut self, first_vertex: u32) -> Self {
43191        self.inner.first_vertex = first_vertex;
43192        self
43193    }
43194    pub fn transform_offset(mut self, transform_offset: u32) -> Self {
43195        self.inner.transform_offset = transform_offset;
43196        self
43197    }
43198    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43199    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43200    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43201    pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR {
43202        self.inner
43203    }
43204}
43205#[repr(C)]
43206#[cfg_attr(feature = "debug", derive(Debug))]
43207#[derive(Copy, Clone)]
43208#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html>"]
43209pub struct AccelerationStructureCreateInfoKHR {
43210    pub s_type: StructureType,
43211    pub p_next: *const c_void,
43212    pub create_flags: AccelerationStructureCreateFlagsKHR,
43213    pub buffer: Buffer,
43214    pub offset: DeviceSize,
43215    pub size: DeviceSize,
43216    pub ty: AccelerationStructureTypeKHR,
43217    pub device_address: DeviceAddress,
43218}
43219impl ::std::default::Default for AccelerationStructureCreateInfoKHR {
43220    fn default() -> Self {
43221        Self {
43222            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
43223            p_next: ::std::ptr::null(),
43224            create_flags: AccelerationStructureCreateFlagsKHR::default(),
43225            buffer: Buffer::default(),
43226            offset: DeviceSize::default(),
43227            size: DeviceSize::default(),
43228            ty: AccelerationStructureTypeKHR::default(),
43229            device_address: DeviceAddress::default(),
43230        }
43231    }
43232}
43233impl AccelerationStructureCreateInfoKHR {
43234    pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> {
43235        AccelerationStructureCreateInfoKHRBuilder {
43236            inner: Self::default(),
43237            marker: ::std::marker::PhantomData,
43238        }
43239    }
43240}
43241#[repr(transparent)]
43242pub struct AccelerationStructureCreateInfoKHRBuilder<'a> {
43243    inner: AccelerationStructureCreateInfoKHR,
43244    marker: ::std::marker::PhantomData<&'a ()>,
43245}
43246pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {}
43247impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> {
43248    type Target = AccelerationStructureCreateInfoKHR;
43249    fn deref(&self) -> &Self::Target {
43250        &self.inner
43251    }
43252}
43253impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> {
43254    fn deref_mut(&mut self) -> &mut Self::Target {
43255        &mut self.inner
43256    }
43257}
43258impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
43259    pub fn create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self {
43260        self.inner.create_flags = create_flags;
43261        self
43262    }
43263    pub fn buffer(mut self, buffer: Buffer) -> Self {
43264        self.inner.buffer = buffer;
43265        self
43266    }
43267    pub fn offset(mut self, offset: DeviceSize) -> Self {
43268        self.inner.offset = offset;
43269        self
43270    }
43271    pub fn size(mut self, size: DeviceSize) -> Self {
43272        self.inner.size = size;
43273        self
43274    }
43275    pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
43276        self.inner.ty = ty;
43277        self
43278    }
43279    pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
43280        self.inner.device_address = device_address;
43281        self
43282    }
43283    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
43284    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
43285    #[doc = r" valid extension structs can be pushed into the chain."]
43286    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
43287    #[doc = r" chain will look like `A -> D -> B -> C`."]
43288    pub fn push_next<T: ExtendsAccelerationStructureCreateInfoKHR>(
43289        mut self,
43290        next: &'a mut T,
43291    ) -> Self {
43292        unsafe {
43293            let next_ptr = <*const T>::cast(next);
43294            let last_next = ptr_chain_iter(next).last().unwrap();
43295            (*last_next).p_next = self.inner.p_next as _;
43296            self.inner.p_next = next_ptr;
43297        }
43298        self
43299    }
43300    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43301    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43302    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43303    pub fn build(self) -> AccelerationStructureCreateInfoKHR {
43304        self.inner
43305    }
43306}
43307#[repr(C)]
43308#[cfg_attr(feature = "debug", derive(Debug))]
43309#[derive(Copy, Clone, Default)]
43310#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAabbPositionsKHR.html>"]
43311pub struct AabbPositionsKHR {
43312    pub min_x: f32,
43313    pub min_y: f32,
43314    pub min_z: f32,
43315    pub max_x: f32,
43316    pub max_y: f32,
43317    pub max_z: f32,
43318}
43319impl AabbPositionsKHR {
43320    pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> {
43321        AabbPositionsKHRBuilder {
43322            inner: Self::default(),
43323            marker: ::std::marker::PhantomData,
43324        }
43325    }
43326}
43327#[repr(transparent)]
43328pub struct AabbPositionsKHRBuilder<'a> {
43329    inner: AabbPositionsKHR,
43330    marker: ::std::marker::PhantomData<&'a ()>,
43331}
43332impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> {
43333    type Target = AabbPositionsKHR;
43334    fn deref(&self) -> &Self::Target {
43335        &self.inner
43336    }
43337}
43338impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> {
43339    fn deref_mut(&mut self) -> &mut Self::Target {
43340        &mut self.inner
43341    }
43342}
43343impl<'a> AabbPositionsKHRBuilder<'a> {
43344    pub fn min_x(mut self, min_x: f32) -> Self {
43345        self.inner.min_x = min_x;
43346        self
43347    }
43348    pub fn min_y(mut self, min_y: f32) -> Self {
43349        self.inner.min_y = min_y;
43350        self
43351    }
43352    pub fn min_z(mut self, min_z: f32) -> Self {
43353        self.inner.min_z = min_z;
43354        self
43355    }
43356    pub fn max_x(mut self, max_x: f32) -> Self {
43357        self.inner.max_x = max_x;
43358        self
43359    }
43360    pub fn max_y(mut self, max_y: f32) -> Self {
43361        self.inner.max_y = max_y;
43362        self
43363    }
43364    pub fn max_z(mut self, max_z: f32) -> Self {
43365        self.inner.max_z = max_z;
43366        self
43367    }
43368    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43369    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43370    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43371    pub fn build(self) -> AabbPositionsKHR {
43372        self.inner
43373    }
43374}
43375#[repr(C)]
43376#[derive(Copy, Clone)]
43377pub struct TransformMatrixKHR {
43378    pub matrix: [f32; 12],
43379}
43380#[repr(C)]
43381#[derive(Copy, Clone)]
43382pub union AccelerationStructureReferenceKHR {
43383    pub device_handle: DeviceAddress,
43384    pub host_handle: AccelerationStructureKHR,
43385}
43386#[repr(C)]
43387#[derive(Copy, Clone)]
43388#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html>"]
43389pub struct AccelerationStructureInstanceKHR {
43390    pub transform: TransformMatrixKHR,
43391    #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
43392    pub instance_custom_index_and_mask: Packed24_8,
43393    #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
43394    pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
43395    pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
43396}
43397#[repr(C)]
43398#[cfg_attr(feature = "debug", derive(Debug))]
43399#[derive(Copy, Clone)]
43400#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>"]
43401pub struct AccelerationStructureDeviceAddressInfoKHR {
43402    pub s_type: StructureType,
43403    pub p_next: *const c_void,
43404    pub acceleration_structure: AccelerationStructureKHR,
43405}
43406impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR {
43407    fn default() -> Self {
43408        Self {
43409            s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
43410            p_next: ::std::ptr::null(),
43411            acceleration_structure: AccelerationStructureKHR::default(),
43412        }
43413    }
43414}
43415impl AccelerationStructureDeviceAddressInfoKHR {
43416    pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43417        AccelerationStructureDeviceAddressInfoKHRBuilder {
43418            inner: Self::default(),
43419            marker: ::std::marker::PhantomData,
43420        }
43421    }
43422}
43423#[repr(transparent)]
43424pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43425    inner: AccelerationStructureDeviceAddressInfoKHR,
43426    marker: ::std::marker::PhantomData<&'a ()>,
43427}
43428impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43429    type Target = AccelerationStructureDeviceAddressInfoKHR;
43430    fn deref(&self) -> &Self::Target {
43431        &self.inner
43432    }
43433}
43434impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43435    fn deref_mut(&mut self) -> &mut Self::Target {
43436        &mut self.inner
43437    }
43438}
43439impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
43440    pub fn acceleration_structure(
43441        mut self,
43442        acceleration_structure: AccelerationStructureKHR,
43443    ) -> Self {
43444        self.inner.acceleration_structure = acceleration_structure;
43445        self
43446    }
43447    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43448    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43449    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43450    pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR {
43451        self.inner
43452    }
43453}
43454#[repr(C)]
43455#[cfg_attr(feature = "debug", derive(Debug))]
43456#[derive(Copy, Clone)]
43457#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureVersionInfoKHR.html>"]
43458pub struct AccelerationStructureVersionInfoKHR {
43459    pub s_type: StructureType,
43460    pub p_next: *const c_void,
43461    pub p_version_data: *const [u8; 2 * UUID_SIZE],
43462}
43463impl ::std::default::Default for AccelerationStructureVersionInfoKHR {
43464    fn default() -> Self {
43465        Self {
43466            s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR,
43467            p_next: ::std::ptr::null(),
43468            p_version_data: ::std::ptr::null(),
43469        }
43470    }
43471}
43472impl AccelerationStructureVersionInfoKHR {
43473    pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> {
43474        AccelerationStructureVersionInfoKHRBuilder {
43475            inner: Self::default(),
43476            marker: ::std::marker::PhantomData,
43477        }
43478    }
43479}
43480#[repr(transparent)]
43481pub struct AccelerationStructureVersionInfoKHRBuilder<'a> {
43482    inner: AccelerationStructureVersionInfoKHR,
43483    marker: ::std::marker::PhantomData<&'a ()>,
43484}
43485impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> {
43486    type Target = AccelerationStructureVersionInfoKHR;
43487    fn deref(&self) -> &Self::Target {
43488        &self.inner
43489    }
43490}
43491impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> {
43492    fn deref_mut(&mut self) -> &mut Self::Target {
43493        &mut self.inner
43494    }
43495}
43496impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> {
43497    pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self {
43498        self.inner.p_version_data = version_data;
43499        self
43500    }
43501    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43502    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43503    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43504    pub fn build(self) -> AccelerationStructureVersionInfoKHR {
43505        self.inner
43506    }
43507}
43508#[repr(C)]
43509#[cfg_attr(feature = "debug", derive(Debug))]
43510#[derive(Copy, Clone)]
43511#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html>"]
43512pub struct CopyAccelerationStructureInfoKHR {
43513    pub s_type: StructureType,
43514    pub p_next: *const c_void,
43515    pub src: AccelerationStructureKHR,
43516    pub dst: AccelerationStructureKHR,
43517    pub mode: CopyAccelerationStructureModeKHR,
43518}
43519impl ::std::default::Default for CopyAccelerationStructureInfoKHR {
43520    fn default() -> Self {
43521        Self {
43522            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR,
43523            p_next: ::std::ptr::null(),
43524            src: AccelerationStructureKHR::default(),
43525            dst: AccelerationStructureKHR::default(),
43526            mode: CopyAccelerationStructureModeKHR::default(),
43527        }
43528    }
43529}
43530impl CopyAccelerationStructureInfoKHR {
43531    pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> {
43532        CopyAccelerationStructureInfoKHRBuilder {
43533            inner: Self::default(),
43534            marker: ::std::marker::PhantomData,
43535        }
43536    }
43537}
43538#[repr(transparent)]
43539pub struct CopyAccelerationStructureInfoKHRBuilder<'a> {
43540    inner: CopyAccelerationStructureInfoKHR,
43541    marker: ::std::marker::PhantomData<&'a ()>,
43542}
43543impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> {
43544    type Target = CopyAccelerationStructureInfoKHR;
43545    fn deref(&self) -> &Self::Target {
43546        &self.inner
43547    }
43548}
43549impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> {
43550    fn deref_mut(&mut self) -> &mut Self::Target {
43551        &mut self.inner
43552    }
43553}
43554impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
43555    pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
43556        self.inner.src = src;
43557        self
43558    }
43559    pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
43560        self.inner.dst = dst;
43561        self
43562    }
43563    pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
43564        self.inner.mode = mode;
43565        self
43566    }
43567    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43568    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43569    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43570    pub fn build(self) -> CopyAccelerationStructureInfoKHR {
43571        self.inner
43572    }
43573}
43574#[repr(C)]
43575#[derive(Copy, Clone)]
43576#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>"]
43577pub struct CopyAccelerationStructureToMemoryInfoKHR {
43578    pub s_type: StructureType,
43579    pub p_next: *const c_void,
43580    pub src: AccelerationStructureKHR,
43581    pub dst: DeviceOrHostAddressKHR,
43582    pub mode: CopyAccelerationStructureModeKHR,
43583}
43584#[cfg(feature = "debug")]
43585impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR {
43586    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43587        fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR")
43588            .field("s_type", &self.s_type)
43589            .field("p_next", &self.p_next)
43590            .field("src", &self.src)
43591            .field("dst", &"union")
43592            .field("mode", &self.mode)
43593            .finish()
43594    }
43595}
43596impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR {
43597    fn default() -> Self {
43598        Self {
43599            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
43600            p_next: ::std::ptr::null(),
43601            src: AccelerationStructureKHR::default(),
43602            dst: DeviceOrHostAddressKHR::default(),
43603            mode: CopyAccelerationStructureModeKHR::default(),
43604        }
43605    }
43606}
43607impl CopyAccelerationStructureToMemoryInfoKHR {
43608    pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43609        CopyAccelerationStructureToMemoryInfoKHRBuilder {
43610            inner: Self::default(),
43611            marker: ::std::marker::PhantomData,
43612        }
43613    }
43614}
43615#[repr(transparent)]
43616pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43617    inner: CopyAccelerationStructureToMemoryInfoKHR,
43618    marker: ::std::marker::PhantomData<&'a ()>,
43619}
43620impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43621    type Target = CopyAccelerationStructureToMemoryInfoKHR;
43622    fn deref(&self) -> &Self::Target {
43623        &self.inner
43624    }
43625}
43626impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43627    fn deref_mut(&mut self) -> &mut Self::Target {
43628        &mut self.inner
43629    }
43630}
43631impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
43632    pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
43633        self.inner.src = src;
43634        self
43635    }
43636    pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self {
43637        self.inner.dst = dst;
43638        self
43639    }
43640    pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
43641        self.inner.mode = mode;
43642        self
43643    }
43644    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43645    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43646    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43647    pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR {
43648        self.inner
43649    }
43650}
43651#[repr(C)]
43652#[derive(Copy, Clone)]
43653#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>"]
43654pub struct CopyMemoryToAccelerationStructureInfoKHR {
43655    pub s_type: StructureType,
43656    pub p_next: *const c_void,
43657    pub src: DeviceOrHostAddressConstKHR,
43658    pub dst: AccelerationStructureKHR,
43659    pub mode: CopyAccelerationStructureModeKHR,
43660}
43661#[cfg(feature = "debug")]
43662impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR {
43663    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43664        fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR")
43665            .field("s_type", &self.s_type)
43666            .field("p_next", &self.p_next)
43667            .field("src", &"union")
43668            .field("dst", &self.dst)
43669            .field("mode", &self.mode)
43670            .finish()
43671    }
43672}
43673impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR {
43674    fn default() -> Self {
43675        Self {
43676            s_type: StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
43677            p_next: ::std::ptr::null(),
43678            src: DeviceOrHostAddressConstKHR::default(),
43679            dst: AccelerationStructureKHR::default(),
43680            mode: CopyAccelerationStructureModeKHR::default(),
43681        }
43682    }
43683}
43684impl CopyMemoryToAccelerationStructureInfoKHR {
43685    pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43686        CopyMemoryToAccelerationStructureInfoKHRBuilder {
43687            inner: Self::default(),
43688            marker: ::std::marker::PhantomData,
43689        }
43690    }
43691}
43692#[repr(transparent)]
43693pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43694    inner: CopyMemoryToAccelerationStructureInfoKHR,
43695    marker: ::std::marker::PhantomData<&'a ()>,
43696}
43697impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43698    type Target = CopyMemoryToAccelerationStructureInfoKHR;
43699    fn deref(&self) -> &Self::Target {
43700        &self.inner
43701    }
43702}
43703impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43704    fn deref_mut(&mut self) -> &mut Self::Target {
43705        &mut self.inner
43706    }
43707}
43708impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
43709    pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self {
43710        self.inner.src = src;
43711        self
43712    }
43713    pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
43714        self.inner.dst = dst;
43715        self
43716    }
43717    pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
43718        self.inner.mode = mode;
43719        self
43720    }
43721    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43722    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43723    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43724    pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR {
43725        self.inner
43726    }
43727}
43728#[repr(C)]
43729#[cfg_attr(feature = "debug", derive(Debug))]
43730#[derive(Copy, Clone)]
43731#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>"]
43732pub struct RayTracingPipelineInterfaceCreateInfoKHR {
43733    pub s_type: StructureType,
43734    pub p_next: *const c_void,
43735    pub max_pipeline_ray_payload_size: u32,
43736    pub max_pipeline_ray_hit_attribute_size: u32,
43737}
43738impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR {
43739    fn default() -> Self {
43740        Self {
43741            s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
43742            p_next: ::std::ptr::null(),
43743            max_pipeline_ray_payload_size: u32::default(),
43744            max_pipeline_ray_hit_attribute_size: u32::default(),
43745        }
43746    }
43747}
43748impl RayTracingPipelineInterfaceCreateInfoKHR {
43749    pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43750        RayTracingPipelineInterfaceCreateInfoKHRBuilder {
43751            inner: Self::default(),
43752            marker: ::std::marker::PhantomData,
43753        }
43754    }
43755}
43756#[repr(transparent)]
43757pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43758    inner: RayTracingPipelineInterfaceCreateInfoKHR,
43759    marker: ::std::marker::PhantomData<&'a ()>,
43760}
43761impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43762    type Target = RayTracingPipelineInterfaceCreateInfoKHR;
43763    fn deref(&self) -> &Self::Target {
43764        &self.inner
43765    }
43766}
43767impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43768    fn deref_mut(&mut self) -> &mut Self::Target {
43769        &mut self.inner
43770    }
43771}
43772impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
43773    pub fn max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self {
43774        self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size;
43775        self
43776    }
43777    pub fn max_pipeline_ray_hit_attribute_size(
43778        mut self,
43779        max_pipeline_ray_hit_attribute_size: u32,
43780    ) -> Self {
43781        self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size;
43782        self
43783    }
43784    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43785    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43786    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43787    pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR {
43788        self.inner
43789    }
43790}
43791#[repr(C)]
43792#[cfg_attr(feature = "debug", derive(Debug))]
43793#[derive(Copy, Clone)]
43794#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html>"]
43795pub struct PipelineLibraryCreateInfoKHR {
43796    pub s_type: StructureType,
43797    pub p_next: *const c_void,
43798    pub library_count: u32,
43799    pub p_libraries: *const Pipeline,
43800}
43801impl ::std::default::Default for PipelineLibraryCreateInfoKHR {
43802    fn default() -> Self {
43803        Self {
43804            s_type: StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR,
43805            p_next: ::std::ptr::null(),
43806            library_count: u32::default(),
43807            p_libraries: ::std::ptr::null(),
43808        }
43809    }
43810}
43811impl PipelineLibraryCreateInfoKHR {
43812    pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> {
43813        PipelineLibraryCreateInfoKHRBuilder {
43814            inner: Self::default(),
43815            marker: ::std::marker::PhantomData,
43816        }
43817    }
43818}
43819#[repr(transparent)]
43820pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
43821    inner: PipelineLibraryCreateInfoKHR,
43822    marker: ::std::marker::PhantomData<&'a ()>,
43823}
43824impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
43825    type Target = PipelineLibraryCreateInfoKHR;
43826    fn deref(&self) -> &Self::Target {
43827        &self.inner
43828    }
43829}
43830impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> {
43831    fn deref_mut(&mut self) -> &mut Self::Target {
43832        &mut self.inner
43833    }
43834}
43835impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
43836    pub fn libraries(mut self, libraries: &'a [Pipeline]) -> Self {
43837        self.inner.library_count = libraries.len() as _;
43838        self.inner.p_libraries = libraries.as_ptr();
43839        self
43840    }
43841    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43842    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43843    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43844    pub fn build(self) -> PipelineLibraryCreateInfoKHR {
43845        self.inner
43846    }
43847}
43848#[repr(C)]
43849#[cfg_attr(feature = "debug", derive(Debug))]
43850#[derive(Copy, Clone)]
43851#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html>"]
43852pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43853    pub s_type: StructureType,
43854    pub p_next: *mut c_void,
43855    pub extended_dynamic_state: Bool32,
43856}
43857impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43858    fn default() -> Self {
43859        Self {
43860            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
43861            p_next: ::std::ptr::null_mut(),
43862            extended_dynamic_state: Bool32::default(),
43863        }
43864    }
43865}
43866impl PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43867    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43868        PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder {
43869            inner: Self::default(),
43870            marker: ::std::marker::PhantomData,
43871        }
43872    }
43873}
43874#[repr(transparent)]
43875pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43876    inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT,
43877    marker: ::std::marker::PhantomData<&'a ()>,
43878}
43879unsafe impl ExtendsPhysicalDeviceFeatures2
43880    for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_>
43881{
43882}
43883unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT {}
43884unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {}
43885unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {}
43886impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43887    type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
43888    fn deref(&self) -> &Self::Target {
43889        &self.inner
43890    }
43891}
43892impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43893    fn deref_mut(&mut self) -> &mut Self::Target {
43894        &mut self.inner
43895    }
43896}
43897impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
43898    pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self {
43899        self.inner.extended_dynamic_state = extended_dynamic_state.into();
43900        self
43901    }
43902    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43903    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43904    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43905    pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT {
43906        self.inner
43907    }
43908}
43909#[repr(C)]
43910#[cfg_attr(feature = "debug", derive(Debug))]
43911#[derive(Copy, Clone)]
43912#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html>"]
43913pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43914    pub s_type: StructureType,
43915    pub p_next: *mut c_void,
43916    pub extended_dynamic_state2: Bool32,
43917    pub extended_dynamic_state2_logic_op: Bool32,
43918    pub extended_dynamic_state2_patch_control_points: Bool32,
43919}
43920impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43921    fn default() -> Self {
43922        Self {
43923            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT,
43924            p_next: ::std::ptr::null_mut(),
43925            extended_dynamic_state2: Bool32::default(),
43926            extended_dynamic_state2_logic_op: Bool32::default(),
43927            extended_dynamic_state2_patch_control_points: Bool32::default(),
43928        }
43929    }
43930}
43931impl PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43932    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43933        PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder {
43934            inner: Self::default(),
43935            marker: ::std::marker::PhantomData,
43936        }
43937    }
43938}
43939#[repr(transparent)]
43940pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43941    inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT,
43942    marker: ::std::marker::PhantomData<&'a ()>,
43943}
43944unsafe impl ExtendsPhysicalDeviceFeatures2
43945    for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_>
43946{
43947}
43948unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT {}
43949unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> {}
43950unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT {}
43951impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43952    type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
43953    fn deref(&self) -> &Self::Target {
43954        &self.inner
43955    }
43956}
43957impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43958    fn deref_mut(&mut self) -> &mut Self::Target {
43959        &mut self.inner
43960    }
43961}
43962impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
43963    pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self {
43964        self.inner.extended_dynamic_state2 = extended_dynamic_state2.into();
43965        self
43966    }
43967    pub fn extended_dynamic_state2_logic_op(
43968        mut self,
43969        extended_dynamic_state2_logic_op: bool,
43970    ) -> Self {
43971        self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into();
43972        self
43973    }
43974    pub fn extended_dynamic_state2_patch_control_points(
43975        mut self,
43976        extended_dynamic_state2_patch_control_points: bool,
43977    ) -> Self {
43978        self.inner.extended_dynamic_state2_patch_control_points =
43979            extended_dynamic_state2_patch_control_points.into();
43980        self
43981    }
43982    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43983    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43984    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
43985    pub fn build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT {
43986        self.inner
43987    }
43988}
43989#[repr(C)]
43990#[cfg_attr(feature = "debug", derive(Debug))]
43991#[derive(Copy, Clone)]
43992#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html>"]
43993pub struct RenderPassTransformBeginInfoQCOM {
43994    pub s_type: StructureType,
43995    pub p_next: *mut c_void,
43996    pub transform: SurfaceTransformFlagsKHR,
43997}
43998impl ::std::default::Default for RenderPassTransformBeginInfoQCOM {
43999    fn default() -> Self {
44000        Self {
44001            s_type: StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
44002            p_next: ::std::ptr::null_mut(),
44003            transform: SurfaceTransformFlagsKHR::default(),
44004        }
44005    }
44006}
44007impl RenderPassTransformBeginInfoQCOM {
44008    pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
44009        RenderPassTransformBeginInfoQCOMBuilder {
44010            inner: Self::default(),
44011            marker: ::std::marker::PhantomData,
44012        }
44013    }
44014}
44015#[repr(transparent)]
44016pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> {
44017    inner: RenderPassTransformBeginInfoQCOM,
44018    marker: ::std::marker::PhantomData<&'a ()>,
44019}
44020unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {}
44021unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {}
44022impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> {
44023    type Target = RenderPassTransformBeginInfoQCOM;
44024    fn deref(&self) -> &Self::Target {
44025        &self.inner
44026    }
44027}
44028impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> {
44029    fn deref_mut(&mut self) -> &mut Self::Target {
44030        &mut self.inner
44031    }
44032}
44033impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
44034    pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
44035        self.inner.transform = transform;
44036        self
44037    }
44038    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44039    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44040    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44041    pub fn build(self) -> RenderPassTransformBeginInfoQCOM {
44042        self.inner
44043    }
44044}
44045#[repr(C)]
44046#[cfg_attr(feature = "debug", derive(Debug))]
44047#[derive(Copy, Clone)]
44048#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyCommandTransformInfoQCOM.html>"]
44049pub struct CopyCommandTransformInfoQCOM {
44050    pub s_type: StructureType,
44051    pub p_next: *const c_void,
44052    pub transform: SurfaceTransformFlagsKHR,
44053}
44054impl ::std::default::Default for CopyCommandTransformInfoQCOM {
44055    fn default() -> Self {
44056        Self {
44057            s_type: StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM,
44058            p_next: ::std::ptr::null(),
44059            transform: SurfaceTransformFlagsKHR::default(),
44060        }
44061    }
44062}
44063impl CopyCommandTransformInfoQCOM {
44064    pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> {
44065        CopyCommandTransformInfoQCOMBuilder {
44066            inner: Self::default(),
44067            marker: ::std::marker::PhantomData,
44068        }
44069    }
44070}
44071#[repr(transparent)]
44072pub struct CopyCommandTransformInfoQCOMBuilder<'a> {
44073    inner: CopyCommandTransformInfoQCOM,
44074    marker: ::std::marker::PhantomData<&'a ()>,
44075}
44076unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
44077unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM {}
44078unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
44079unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM {}
44080impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> {
44081    type Target = CopyCommandTransformInfoQCOM;
44082    fn deref(&self) -> &Self::Target {
44083        &self.inner
44084    }
44085}
44086impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> {
44087    fn deref_mut(&mut self) -> &mut Self::Target {
44088        &mut self.inner
44089    }
44090}
44091impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> {
44092    pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
44093        self.inner.transform = transform;
44094        self
44095    }
44096    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44097    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44098    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44099    pub fn build(self) -> CopyCommandTransformInfoQCOM {
44100        self.inner
44101    }
44102}
44103#[repr(C)]
44104#[cfg_attr(feature = "debug", derive(Debug))]
44105#[derive(Copy, Clone)]
44106#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>"]
44107pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
44108    pub s_type: StructureType,
44109    pub p_next: *mut c_void,
44110    pub transform: SurfaceTransformFlagsKHR,
44111    pub render_area: Rect2D,
44112}
44113impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM {
44114    fn default() -> Self {
44115        Self {
44116            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
44117            p_next: ::std::ptr::null_mut(),
44118            transform: SurfaceTransformFlagsKHR::default(),
44119            render_area: Rect2D::default(),
44120        }
44121    }
44122}
44123impl CommandBufferInheritanceRenderPassTransformInfoQCOM {
44124    pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44125        CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder {
44126            inner: Self::default(),
44127            marker: ::std::marker::PhantomData,
44128        }
44129    }
44130}
44131#[repr(transparent)]
44132pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44133    inner: CommandBufferInheritanceRenderPassTransformInfoQCOM,
44134    marker: ::std::marker::PhantomData<&'a ()>,
44135}
44136unsafe impl ExtendsCommandBufferInheritanceInfo
44137    for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_>
44138{
44139}
44140unsafe impl ExtendsCommandBufferInheritanceInfo
44141    for CommandBufferInheritanceRenderPassTransformInfoQCOM
44142{
44143}
44144impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44145    type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM;
44146    fn deref(&self) -> &Self::Target {
44147        &self.inner
44148    }
44149}
44150impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44151    fn deref_mut(&mut self) -> &mut Self::Target {
44152        &mut self.inner
44153    }
44154}
44155impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
44156    pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
44157        self.inner.transform = transform;
44158        self
44159    }
44160    pub fn render_area(mut self, render_area: Rect2D) -> Self {
44161        self.inner.render_area = render_area;
44162        self
44163    }
44164    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44165    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44166    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44167    pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
44168        self.inner
44169    }
44170}
44171#[repr(C)]
44172#[cfg_attr(feature = "debug", derive(Debug))]
44173#[derive(Copy, Clone)]
44174#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>"]
44175pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
44176    pub s_type: StructureType,
44177    pub p_next: *mut c_void,
44178    pub diagnostics_config: Bool32,
44179}
44180impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV {
44181    fn default() -> Self {
44182        Self {
44183            s_type: StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
44184            p_next: ::std::ptr::null_mut(),
44185            diagnostics_config: Bool32::default(),
44186        }
44187    }
44188}
44189impl PhysicalDeviceDiagnosticsConfigFeaturesNV {
44190    pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44191        PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder {
44192            inner: Self::default(),
44193            marker: ::std::marker::PhantomData,
44194        }
44195    }
44196}
44197#[repr(transparent)]
44198pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44199    inner: PhysicalDeviceDiagnosticsConfigFeaturesNV,
44200    marker: ::std::marker::PhantomData<&'a ()>,
44201}
44202unsafe impl ExtendsPhysicalDeviceFeatures2
44203    for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_>
44204{
44205}
44206unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
44207unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {}
44208unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
44209impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44210    type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV;
44211    fn deref(&self) -> &Self::Target {
44212        &self.inner
44213    }
44214}
44215impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44216    fn deref_mut(&mut self) -> &mut Self::Target {
44217        &mut self.inner
44218    }
44219}
44220impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
44221    pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self {
44222        self.inner.diagnostics_config = diagnostics_config.into();
44223        self
44224    }
44225    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44226    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44227    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44228    pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
44229        self.inner
44230    }
44231}
44232#[repr(C)]
44233#[cfg_attr(feature = "debug", derive(Debug))]
44234#[derive(Copy, Clone)]
44235#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>"]
44236pub struct DeviceDiagnosticsConfigCreateInfoNV {
44237    pub s_type: StructureType,
44238    pub p_next: *const c_void,
44239    pub flags: DeviceDiagnosticsConfigFlagsNV,
44240}
44241impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV {
44242    fn default() -> Self {
44243        Self {
44244            s_type: StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
44245            p_next: ::std::ptr::null(),
44246            flags: DeviceDiagnosticsConfigFlagsNV::default(),
44247        }
44248    }
44249}
44250impl DeviceDiagnosticsConfigCreateInfoNV {
44251    pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44252        DeviceDiagnosticsConfigCreateInfoNVBuilder {
44253            inner: Self::default(),
44254            marker: ::std::marker::PhantomData,
44255        }
44256    }
44257}
44258#[repr(transparent)]
44259pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44260    inner: DeviceDiagnosticsConfigCreateInfoNV,
44261    marker: ::std::marker::PhantomData<&'a ()>,
44262}
44263unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {}
44264unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {}
44265impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44266    type Target = DeviceDiagnosticsConfigCreateInfoNV;
44267    fn deref(&self) -> &Self::Target {
44268        &self.inner
44269    }
44270}
44271impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44272    fn deref_mut(&mut self) -> &mut Self::Target {
44273        &mut self.inner
44274    }
44275}
44276impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
44277    pub fn flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self {
44278        self.inner.flags = flags;
44279        self
44280    }
44281    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44282    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44283    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44284    pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV {
44285        self.inner
44286    }
44287}
44288#[repr(C)]
44289#[cfg_attr(feature = "debug", derive(Debug))]
44290#[derive(Copy, Clone)]
44291#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html>"]
44292pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44293    pub s_type: StructureType,
44294    pub p_next: *mut c_void,
44295    pub shader_zero_initialize_workgroup_memory: Bool32,
44296}
44297impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44298    fn default() -> Self {
44299        Self {
44300            s_type: StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES,
44301            p_next: ::std::ptr::null_mut(),
44302            shader_zero_initialize_workgroup_memory: Bool32::default(),
44303        }
44304    }
44305}
44306impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44307    pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44308        PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder {
44309            inner: Self::default(),
44310            marker: ::std::marker::PhantomData,
44311        }
44312    }
44313}
44314#[repr(transparent)]
44315pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44316    inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
44317    marker: ::std::marker::PhantomData<&'a ()>,
44318}
44319unsafe impl ExtendsPhysicalDeviceFeatures2
44320    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
44321{
44322}
44323unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
44324unsafe impl ExtendsDeviceCreateInfo
44325    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
44326{
44327}
44328unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
44329impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44330    type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
44331    fn deref(&self) -> &Self::Target {
44332        &self.inner
44333    }
44334}
44335impl<'a> ::std::ops::DerefMut for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44336    fn deref_mut(&mut self) -> &mut Self::Target {
44337        &mut self.inner
44338    }
44339}
44340impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
44341    pub fn shader_zero_initialize_workgroup_memory(
44342        mut self,
44343        shader_zero_initialize_workgroup_memory: bool,
44344    ) -> Self {
44345        self.inner.shader_zero_initialize_workgroup_memory =
44346            shader_zero_initialize_workgroup_memory.into();
44347        self
44348    }
44349    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44350    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44351    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44352    pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
44353        self.inner
44354    }
44355}
44356#[repr(C)]
44357#[cfg_attr(feature = "debug", derive(Debug))]
44358#[derive(Copy, Clone)]
44359#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html>"]
44360pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44361    pub s_type: StructureType,
44362    pub p_next: *mut c_void,
44363    pub shader_subgroup_uniform_control_flow: Bool32,
44364}
44365impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44366    fn default() -> Self {
44367        Self {
44368            s_type:
44369                StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR,
44370            p_next: ::std::ptr::null_mut(),
44371            shader_subgroup_uniform_control_flow: Bool32::default(),
44372        }
44373    }
44374}
44375impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44376    pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
44377        PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder {
44378            inner: Self::default(),
44379            marker: ::std::marker::PhantomData,
44380        }
44381    }
44382}
44383#[repr(transparent)]
44384pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
44385    inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR,
44386    marker: ::std::marker::PhantomData<&'a ()>,
44387}
44388unsafe impl ExtendsPhysicalDeviceFeatures2
44389    for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_>
44390{
44391}
44392unsafe impl ExtendsPhysicalDeviceFeatures2
44393    for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
44394{
44395}
44396unsafe impl ExtendsDeviceCreateInfo
44397    for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_>
44398{
44399}
44400unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {}
44401impl<'a> ::std::ops::Deref
44402    for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a>
44403{
44404    type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
44405    fn deref(&self) -> &Self::Target {
44406        &self.inner
44407    }
44408}
44409impl<'a> ::std::ops::DerefMut
44410    for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a>
44411{
44412    fn deref_mut(&mut self) -> &mut Self::Target {
44413        &mut self.inner
44414    }
44415}
44416impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
44417    pub fn shader_subgroup_uniform_control_flow(
44418        mut self,
44419        shader_subgroup_uniform_control_flow: bool,
44420    ) -> Self {
44421        self.inner.shader_subgroup_uniform_control_flow =
44422            shader_subgroup_uniform_control_flow.into();
44423        self
44424    }
44425    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44426    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44427    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44428    pub fn build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
44429        self.inner
44430    }
44431}
44432#[repr(C)]
44433#[cfg_attr(feature = "debug", derive(Debug))]
44434#[derive(Copy, Clone)]
44435#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html>"]
44436pub struct PhysicalDeviceRobustness2FeaturesEXT {
44437    pub s_type: StructureType,
44438    pub p_next: *mut c_void,
44439    pub robust_buffer_access2: Bool32,
44440    pub robust_image_access2: Bool32,
44441    pub null_descriptor: Bool32,
44442}
44443impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT {
44444    fn default() -> Self {
44445        Self {
44446            s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
44447            p_next: ::std::ptr::null_mut(),
44448            robust_buffer_access2: Bool32::default(),
44449            robust_image_access2: Bool32::default(),
44450            null_descriptor: Bool32::default(),
44451        }
44452    }
44453}
44454impl PhysicalDeviceRobustness2FeaturesEXT {
44455    pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44456        PhysicalDeviceRobustness2FeaturesEXTBuilder {
44457            inner: Self::default(),
44458            marker: ::std::marker::PhantomData,
44459        }
44460    }
44461}
44462#[repr(transparent)]
44463pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44464    inner: PhysicalDeviceRobustness2FeaturesEXT,
44465    marker: ::std::marker::PhantomData<&'a ()>,
44466}
44467unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {}
44468unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT {}
44469unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {}
44470unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {}
44471impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44472    type Target = PhysicalDeviceRobustness2FeaturesEXT;
44473    fn deref(&self) -> &Self::Target {
44474        &self.inner
44475    }
44476}
44477impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44478    fn deref_mut(&mut self) -> &mut Self::Target {
44479        &mut self.inner
44480    }
44481}
44482impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
44483    pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self {
44484        self.inner.robust_buffer_access2 = robust_buffer_access2.into();
44485        self
44486    }
44487    pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self {
44488        self.inner.robust_image_access2 = robust_image_access2.into();
44489        self
44490    }
44491    pub fn null_descriptor(mut self, null_descriptor: bool) -> Self {
44492        self.inner.null_descriptor = null_descriptor.into();
44493        self
44494    }
44495    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44496    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44497    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44498    pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT {
44499        self.inner
44500    }
44501}
44502#[repr(C)]
44503#[cfg_attr(feature = "debug", derive(Debug))]
44504#[derive(Copy, Clone)]
44505#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html>"]
44506pub struct PhysicalDeviceRobustness2PropertiesEXT {
44507    pub s_type: StructureType,
44508    pub p_next: *mut c_void,
44509    pub robust_storage_buffer_access_size_alignment: DeviceSize,
44510    pub robust_uniform_buffer_access_size_alignment: DeviceSize,
44511}
44512impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT {
44513    fn default() -> Self {
44514        Self {
44515            s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
44516            p_next: ::std::ptr::null_mut(),
44517            robust_storage_buffer_access_size_alignment: DeviceSize::default(),
44518            robust_uniform_buffer_access_size_alignment: DeviceSize::default(),
44519        }
44520    }
44521}
44522impl PhysicalDeviceRobustness2PropertiesEXT {
44523    pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44524        PhysicalDeviceRobustness2PropertiesEXTBuilder {
44525            inner: Self::default(),
44526            marker: ::std::marker::PhantomData,
44527        }
44528    }
44529}
44530#[repr(transparent)]
44531pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44532    inner: PhysicalDeviceRobustness2PropertiesEXT,
44533    marker: ::std::marker::PhantomData<&'a ()>,
44534}
44535unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {}
44536unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {}
44537impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44538    type Target = PhysicalDeviceRobustness2PropertiesEXT;
44539    fn deref(&self) -> &Self::Target {
44540        &self.inner
44541    }
44542}
44543impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44544    fn deref_mut(&mut self) -> &mut Self::Target {
44545        &mut self.inner
44546    }
44547}
44548impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
44549    pub fn robust_storage_buffer_access_size_alignment(
44550        mut self,
44551        robust_storage_buffer_access_size_alignment: DeviceSize,
44552    ) -> Self {
44553        self.inner.robust_storage_buffer_access_size_alignment =
44554            robust_storage_buffer_access_size_alignment;
44555        self
44556    }
44557    pub fn robust_uniform_buffer_access_size_alignment(
44558        mut self,
44559        robust_uniform_buffer_access_size_alignment: DeviceSize,
44560    ) -> Self {
44561        self.inner.robust_uniform_buffer_access_size_alignment =
44562            robust_uniform_buffer_access_size_alignment;
44563        self
44564    }
44565    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44566    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44567    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44568    pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT {
44569        self.inner
44570    }
44571}
44572#[repr(C)]
44573#[cfg_attr(feature = "debug", derive(Debug))]
44574#[derive(Copy, Clone)]
44575#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageRobustnessFeatures.html>"]
44576pub struct PhysicalDeviceImageRobustnessFeatures {
44577    pub s_type: StructureType,
44578    pub p_next: *mut c_void,
44579    pub robust_image_access: Bool32,
44580}
44581impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures {
44582    fn default() -> Self {
44583        Self {
44584            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES,
44585            p_next: ::std::ptr::null_mut(),
44586            robust_image_access: Bool32::default(),
44587        }
44588    }
44589}
44590impl PhysicalDeviceImageRobustnessFeatures {
44591    pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44592        PhysicalDeviceImageRobustnessFeaturesBuilder {
44593            inner: Self::default(),
44594            marker: ::std::marker::PhantomData,
44595        }
44596    }
44597}
44598#[repr(transparent)]
44599pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44600    inner: PhysicalDeviceImageRobustnessFeatures,
44601    marker: ::std::marker::PhantomData<&'a ()>,
44602}
44603unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
44604unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures {}
44605unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
44606unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures {}
44607impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44608    type Target = PhysicalDeviceImageRobustnessFeatures;
44609    fn deref(&self) -> &Self::Target {
44610        &self.inner
44611    }
44612}
44613impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44614    fn deref_mut(&mut self) -> &mut Self::Target {
44615        &mut self.inner
44616    }
44617}
44618impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
44619    pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
44620        self.inner.robust_image_access = robust_image_access.into();
44621        self
44622    }
44623    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44624    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44625    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44626    pub fn build(self) -> PhysicalDeviceImageRobustnessFeatures {
44627        self.inner
44628    }
44629}
44630#[repr(C)]
44631#[cfg_attr(feature = "debug", derive(Debug))]
44632#[derive(Copy, Clone)]
44633#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html>"]
44634pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44635    pub s_type: StructureType,
44636    pub p_next: *mut c_void,
44637    pub workgroup_memory_explicit_layout: Bool32,
44638    pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32,
44639    pub workgroup_memory_explicit_layout8_bit_access: Bool32,
44640    pub workgroup_memory_explicit_layout16_bit_access: Bool32,
44641}
44642impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44643    fn default() -> Self {
44644        Self {
44645            s_type: StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
44646            p_next: ::std::ptr::null_mut(),
44647            workgroup_memory_explicit_layout: Bool32::default(),
44648            workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(),
44649            workgroup_memory_explicit_layout8_bit_access: Bool32::default(),
44650            workgroup_memory_explicit_layout16_bit_access: Bool32::default(),
44651        }
44652    }
44653}
44654impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44655    pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44656        PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder {
44657            inner: Self::default(),
44658            marker: ::std::marker::PhantomData,
44659        }
44660    }
44661}
44662#[repr(transparent)]
44663pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44664    inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR,
44665    marker: ::std::marker::PhantomData<&'a ()>,
44666}
44667unsafe impl ExtendsPhysicalDeviceFeatures2
44668    for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_>
44669{
44670}
44671unsafe impl ExtendsPhysicalDeviceFeatures2
44672    for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
44673{
44674}
44675unsafe impl ExtendsDeviceCreateInfo
44676    for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_>
44677{
44678}
44679unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {}
44680impl<'a> ::std::ops::Deref for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44681    type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
44682    fn deref(&self) -> &Self::Target {
44683        &self.inner
44684    }
44685}
44686impl<'a> ::std::ops::DerefMut
44687    for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>
44688{
44689    fn deref_mut(&mut self) -> &mut Self::Target {
44690        &mut self.inner
44691    }
44692}
44693impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
44694    pub fn workgroup_memory_explicit_layout(
44695        mut self,
44696        workgroup_memory_explicit_layout: bool,
44697    ) -> Self {
44698        self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into();
44699        self
44700    }
44701    pub fn workgroup_memory_explicit_layout_scalar_block_layout(
44702        mut self,
44703        workgroup_memory_explicit_layout_scalar_block_layout: bool,
44704    ) -> Self {
44705        self.inner
44706            .workgroup_memory_explicit_layout_scalar_block_layout =
44707            workgroup_memory_explicit_layout_scalar_block_layout.into();
44708        self
44709    }
44710    pub fn workgroup_memory_explicit_layout8_bit_access(
44711        mut self,
44712        workgroup_memory_explicit_layout8_bit_access: bool,
44713    ) -> Self {
44714        self.inner.workgroup_memory_explicit_layout8_bit_access =
44715            workgroup_memory_explicit_layout8_bit_access.into();
44716        self
44717    }
44718    pub fn workgroup_memory_explicit_layout16_bit_access(
44719        mut self,
44720        workgroup_memory_explicit_layout16_bit_access: bool,
44721    ) -> Self {
44722        self.inner.workgroup_memory_explicit_layout16_bit_access =
44723            workgroup_memory_explicit_layout16_bit_access.into();
44724        self
44725    }
44726    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44727    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44728    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44729    pub fn build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
44730        self.inner
44731    }
44732}
44733#[repr(C)]
44734#[cfg_attr(feature = "debug", derive(Debug))]
44735#[derive(Copy, Clone)]
44736#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html>"]
44737pub struct PhysicalDevicePortabilitySubsetFeaturesKHR {
44738    pub s_type: StructureType,
44739    pub p_next: *mut c_void,
44740    pub constant_alpha_color_blend_factors: Bool32,
44741    pub events: Bool32,
44742    pub image_view_format_reinterpretation: Bool32,
44743    pub image_view_format_swizzle: Bool32,
44744    pub image_view2_d_on3_d_image: Bool32,
44745    pub multisample_array_image: Bool32,
44746    pub mutable_comparison_samplers: Bool32,
44747    pub point_polygons: Bool32,
44748    pub sampler_mip_lod_bias: Bool32,
44749    pub separate_stencil_mask_ref: Bool32,
44750    pub shader_sample_rate_interpolation_functions: Bool32,
44751    pub tessellation_isolines: Bool32,
44752    pub tessellation_point_mode: Bool32,
44753    pub triangle_fans: Bool32,
44754    pub vertex_attribute_access_beyond_stride: Bool32,
44755}
44756impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR {
44757    fn default() -> Self {
44758        Self {
44759            s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
44760            p_next: ::std::ptr::null_mut(),
44761            constant_alpha_color_blend_factors: Bool32::default(),
44762            events: Bool32::default(),
44763            image_view_format_reinterpretation: Bool32::default(),
44764            image_view_format_swizzle: Bool32::default(),
44765            image_view2_d_on3_d_image: Bool32::default(),
44766            multisample_array_image: Bool32::default(),
44767            mutable_comparison_samplers: Bool32::default(),
44768            point_polygons: Bool32::default(),
44769            sampler_mip_lod_bias: Bool32::default(),
44770            separate_stencil_mask_ref: Bool32::default(),
44771            shader_sample_rate_interpolation_functions: Bool32::default(),
44772            tessellation_isolines: Bool32::default(),
44773            tessellation_point_mode: Bool32::default(),
44774            triangle_fans: Bool32::default(),
44775            vertex_attribute_access_beyond_stride: Bool32::default(),
44776        }
44777    }
44778}
44779impl PhysicalDevicePortabilitySubsetFeaturesKHR {
44780    pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44781        PhysicalDevicePortabilitySubsetFeaturesKHRBuilder {
44782            inner: Self::default(),
44783            marker: ::std::marker::PhantomData,
44784        }
44785    }
44786}
44787#[repr(transparent)]
44788pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44789    inner: PhysicalDevicePortabilitySubsetFeaturesKHR,
44790    marker: ::std::marker::PhantomData<&'a ()>,
44791}
44792unsafe impl ExtendsPhysicalDeviceFeatures2
44793    for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_>
44794{
44795}
44796unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR {}
44797unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {}
44798unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {}
44799impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44800    type Target = PhysicalDevicePortabilitySubsetFeaturesKHR;
44801    fn deref(&self) -> &Self::Target {
44802        &self.inner
44803    }
44804}
44805impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44806    fn deref_mut(&mut self) -> &mut Self::Target {
44807        &mut self.inner
44808    }
44809}
44810impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
44811    pub fn constant_alpha_color_blend_factors(
44812        mut self,
44813        constant_alpha_color_blend_factors: bool,
44814    ) -> Self {
44815        self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into();
44816        self
44817    }
44818    pub fn events(mut self, events: bool) -> Self {
44819        self.inner.events = events.into();
44820        self
44821    }
44822    pub fn image_view_format_reinterpretation(
44823        mut self,
44824        image_view_format_reinterpretation: bool,
44825    ) -> Self {
44826        self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into();
44827        self
44828    }
44829    pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self {
44830        self.inner.image_view_format_swizzle = image_view_format_swizzle.into();
44831        self
44832    }
44833    pub fn image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self {
44834        self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into();
44835        self
44836    }
44837    pub fn multisample_array_image(mut self, multisample_array_image: bool) -> Self {
44838        self.inner.multisample_array_image = multisample_array_image.into();
44839        self
44840    }
44841    pub fn mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self {
44842        self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into();
44843        self
44844    }
44845    pub fn point_polygons(mut self, point_polygons: bool) -> Self {
44846        self.inner.point_polygons = point_polygons.into();
44847        self
44848    }
44849    pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self {
44850        self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into();
44851        self
44852    }
44853    pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self {
44854        self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into();
44855        self
44856    }
44857    pub fn shader_sample_rate_interpolation_functions(
44858        mut self,
44859        shader_sample_rate_interpolation_functions: bool,
44860    ) -> Self {
44861        self.inner.shader_sample_rate_interpolation_functions =
44862            shader_sample_rate_interpolation_functions.into();
44863        self
44864    }
44865    pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self {
44866        self.inner.tessellation_isolines = tessellation_isolines.into();
44867        self
44868    }
44869    pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self {
44870        self.inner.tessellation_point_mode = tessellation_point_mode.into();
44871        self
44872    }
44873    pub fn triangle_fans(mut self, triangle_fans: bool) -> Self {
44874        self.inner.triangle_fans = triangle_fans.into();
44875        self
44876    }
44877    pub fn vertex_attribute_access_beyond_stride(
44878        mut self,
44879        vertex_attribute_access_beyond_stride: bool,
44880    ) -> Self {
44881        self.inner.vertex_attribute_access_beyond_stride =
44882            vertex_attribute_access_beyond_stride.into();
44883        self
44884    }
44885    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44886    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44887    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44888    pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR {
44889        self.inner
44890    }
44891}
44892#[repr(C)]
44893#[cfg_attr(feature = "debug", derive(Debug))]
44894#[derive(Copy, Clone)]
44895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html>"]
44896pub struct PhysicalDevicePortabilitySubsetPropertiesKHR {
44897    pub s_type: StructureType,
44898    pub p_next: *mut c_void,
44899    pub min_vertex_input_binding_stride_alignment: u32,
44900}
44901impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR {
44902    fn default() -> Self {
44903        Self {
44904            s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
44905            p_next: ::std::ptr::null_mut(),
44906            min_vertex_input_binding_stride_alignment: u32::default(),
44907        }
44908    }
44909}
44910impl PhysicalDevicePortabilitySubsetPropertiesKHR {
44911    pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44912        PhysicalDevicePortabilitySubsetPropertiesKHRBuilder {
44913            inner: Self::default(),
44914            marker: ::std::marker::PhantomData,
44915        }
44916    }
44917}
44918#[repr(transparent)]
44919pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44920    inner: PhysicalDevicePortabilitySubsetPropertiesKHR,
44921    marker: ::std::marker::PhantomData<&'a ()>,
44922}
44923unsafe impl ExtendsPhysicalDeviceProperties2
44924    for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_>
44925{
44926}
44927unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {}
44928impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44929    type Target = PhysicalDevicePortabilitySubsetPropertiesKHR;
44930    fn deref(&self) -> &Self::Target {
44931        &self.inner
44932    }
44933}
44934impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44935    fn deref_mut(&mut self) -> &mut Self::Target {
44936        &mut self.inner
44937    }
44938}
44939impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
44940    pub fn min_vertex_input_binding_stride_alignment(
44941        mut self,
44942        min_vertex_input_binding_stride_alignment: u32,
44943    ) -> Self {
44944        self.inner.min_vertex_input_binding_stride_alignment =
44945            min_vertex_input_binding_stride_alignment;
44946        self
44947    }
44948    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44949    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44950    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
44951    pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR {
44952        self.inner
44953    }
44954}
44955#[repr(C)]
44956#[cfg_attr(feature = "debug", derive(Debug))]
44957#[derive(Copy, Clone)]
44958#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html>"]
44959pub struct PhysicalDevice4444FormatsFeaturesEXT {
44960    pub s_type: StructureType,
44961    pub p_next: *mut c_void,
44962    pub format_a4r4g4b4: Bool32,
44963    pub format_a4b4g4r4: Bool32,
44964}
44965impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT {
44966    fn default() -> Self {
44967        Self {
44968            s_type: StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
44969            p_next: ::std::ptr::null_mut(),
44970            format_a4r4g4b4: Bool32::default(),
44971            format_a4b4g4r4: Bool32::default(),
44972        }
44973    }
44974}
44975impl PhysicalDevice4444FormatsFeaturesEXT {
44976    pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44977        PhysicalDevice4444FormatsFeaturesEXTBuilder {
44978            inner: Self::default(),
44979            marker: ::std::marker::PhantomData,
44980        }
44981    }
44982}
44983#[repr(transparent)]
44984pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44985    inner: PhysicalDevice4444FormatsFeaturesEXT,
44986    marker: ::std::marker::PhantomData<&'a ()>,
44987}
44988unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {}
44989unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT {}
44990unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {}
44991unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {}
44992impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44993    type Target = PhysicalDevice4444FormatsFeaturesEXT;
44994    fn deref(&self) -> &Self::Target {
44995        &self.inner
44996    }
44997}
44998impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
44999    fn deref_mut(&mut self) -> &mut Self::Target {
45000        &mut self.inner
45001    }
45002}
45003impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
45004    pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self {
45005        self.inner.format_a4r4g4b4 = format_a4r4g4b4.into();
45006        self
45007    }
45008    pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self {
45009        self.inner.format_a4b4g4r4 = format_a4b4g4r4.into();
45010        self
45011    }
45012    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45013    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45014    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45015    pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT {
45016        self.inner
45017    }
45018}
45019#[repr(C)]
45020#[cfg_attr(feature = "debug", derive(Debug))]
45021#[derive(Copy, Clone)]
45022#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html>"]
45023pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45024    pub s_type: StructureType,
45025    pub p_next: *mut c_void,
45026    pub subpass_shading: Bool32,
45027}
45028impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45029    fn default() -> Self {
45030        Self {
45031            s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI,
45032            p_next: ::std::ptr::null_mut(),
45033            subpass_shading: Bool32::default(),
45034        }
45035    }
45036}
45037impl PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45038    pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45039        PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder {
45040            inner: Self::default(),
45041            marker: ::std::marker::PhantomData,
45042        }
45043    }
45044}
45045#[repr(transparent)]
45046pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45047    inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI,
45048    marker: ::std::marker::PhantomData<&'a ()>,
45049}
45050unsafe impl ExtendsPhysicalDeviceFeatures2
45051    for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_>
45052{
45053}
45054unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI {}
45055unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> {}
45056unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI {}
45057impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45058    type Target = PhysicalDeviceSubpassShadingFeaturesHUAWEI;
45059    fn deref(&self) -> &Self::Target {
45060        &self.inner
45061    }
45062}
45063impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45064    fn deref_mut(&mut self) -> &mut Self::Target {
45065        &mut self.inner
45066    }
45067}
45068impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
45069    pub fn subpass_shading(mut self, subpass_shading: bool) -> Self {
45070        self.inner.subpass_shading = subpass_shading.into();
45071        self
45072    }
45073    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45074    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45075    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45076    pub fn build(self) -> PhysicalDeviceSubpassShadingFeaturesHUAWEI {
45077        self.inner
45078    }
45079}
45080#[repr(C)]
45081#[cfg_attr(feature = "debug", derive(Debug))]
45082#[derive(Copy, Clone)]
45083#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy2.html>"]
45084pub struct BufferCopy2 {
45085    pub s_type: StructureType,
45086    pub p_next: *const c_void,
45087    pub src_offset: DeviceSize,
45088    pub dst_offset: DeviceSize,
45089    pub size: DeviceSize,
45090}
45091impl ::std::default::Default for BufferCopy2 {
45092    fn default() -> Self {
45093        Self {
45094            s_type: StructureType::BUFFER_COPY_2,
45095            p_next: ::std::ptr::null(),
45096            src_offset: DeviceSize::default(),
45097            dst_offset: DeviceSize::default(),
45098            size: DeviceSize::default(),
45099        }
45100    }
45101}
45102impl BufferCopy2 {
45103    pub fn builder<'a>() -> BufferCopy2Builder<'a> {
45104        BufferCopy2Builder {
45105            inner: Self::default(),
45106            marker: ::std::marker::PhantomData,
45107        }
45108    }
45109}
45110#[repr(transparent)]
45111pub struct BufferCopy2Builder<'a> {
45112    inner: BufferCopy2,
45113    marker: ::std::marker::PhantomData<&'a ()>,
45114}
45115impl<'a> ::std::ops::Deref for BufferCopy2Builder<'a> {
45116    type Target = BufferCopy2;
45117    fn deref(&self) -> &Self::Target {
45118        &self.inner
45119    }
45120}
45121impl<'a> ::std::ops::DerefMut for BufferCopy2Builder<'a> {
45122    fn deref_mut(&mut self) -> &mut Self::Target {
45123        &mut self.inner
45124    }
45125}
45126impl<'a> BufferCopy2Builder<'a> {
45127    pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
45128        self.inner.src_offset = src_offset;
45129        self
45130    }
45131    pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
45132        self.inner.dst_offset = dst_offset;
45133        self
45134    }
45135    pub fn size(mut self, size: DeviceSize) -> Self {
45136        self.inner.size = size;
45137        self
45138    }
45139    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45140    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45141    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45142    pub fn build(self) -> BufferCopy2 {
45143        self.inner
45144    }
45145}
45146#[repr(C)]
45147#[cfg_attr(feature = "debug", derive(Debug))]
45148#[derive(Copy, Clone)]
45149#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy2.html>"]
45150pub struct ImageCopy2 {
45151    pub s_type: StructureType,
45152    pub p_next: *const c_void,
45153    pub src_subresource: ImageSubresourceLayers,
45154    pub src_offset: Offset3D,
45155    pub dst_subresource: ImageSubresourceLayers,
45156    pub dst_offset: Offset3D,
45157    pub extent: Extent3D,
45158}
45159impl ::std::default::Default for ImageCopy2 {
45160    fn default() -> Self {
45161        Self {
45162            s_type: StructureType::IMAGE_COPY_2,
45163            p_next: ::std::ptr::null(),
45164            src_subresource: ImageSubresourceLayers::default(),
45165            src_offset: Offset3D::default(),
45166            dst_subresource: ImageSubresourceLayers::default(),
45167            dst_offset: Offset3D::default(),
45168            extent: Extent3D::default(),
45169        }
45170    }
45171}
45172impl ImageCopy2 {
45173    pub fn builder<'a>() -> ImageCopy2Builder<'a> {
45174        ImageCopy2Builder {
45175            inner: Self::default(),
45176            marker: ::std::marker::PhantomData,
45177        }
45178    }
45179}
45180#[repr(transparent)]
45181pub struct ImageCopy2Builder<'a> {
45182    inner: ImageCopy2,
45183    marker: ::std::marker::PhantomData<&'a ()>,
45184}
45185impl<'a> ::std::ops::Deref for ImageCopy2Builder<'a> {
45186    type Target = ImageCopy2;
45187    fn deref(&self) -> &Self::Target {
45188        &self.inner
45189    }
45190}
45191impl<'a> ::std::ops::DerefMut for ImageCopy2Builder<'a> {
45192    fn deref_mut(&mut self) -> &mut Self::Target {
45193        &mut self.inner
45194    }
45195}
45196impl<'a> ImageCopy2Builder<'a> {
45197    pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
45198        self.inner.src_subresource = src_subresource;
45199        self
45200    }
45201    pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
45202        self.inner.src_offset = src_offset;
45203        self
45204    }
45205    pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
45206        self.inner.dst_subresource = dst_subresource;
45207        self
45208    }
45209    pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
45210        self.inner.dst_offset = dst_offset;
45211        self
45212    }
45213    pub fn extent(mut self, extent: Extent3D) -> Self {
45214        self.inner.extent = extent;
45215        self
45216    }
45217    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45218    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45219    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45220    pub fn build(self) -> ImageCopy2 {
45221        self.inner
45222    }
45223}
45224#[repr(C)]
45225#[cfg_attr(feature = "debug", derive(Debug))]
45226#[derive(Copy, Clone)]
45227#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit2.html>"]
45228pub struct ImageBlit2 {
45229    pub s_type: StructureType,
45230    pub p_next: *const c_void,
45231    pub src_subresource: ImageSubresourceLayers,
45232    pub src_offsets: [Offset3D; 2],
45233    pub dst_subresource: ImageSubresourceLayers,
45234    pub dst_offsets: [Offset3D; 2],
45235}
45236impl ::std::default::Default for ImageBlit2 {
45237    fn default() -> Self {
45238        Self {
45239            s_type: StructureType::IMAGE_BLIT_2,
45240            p_next: ::std::ptr::null(),
45241            src_subresource: ImageSubresourceLayers::default(),
45242            src_offsets: unsafe { ::std::mem::zeroed() },
45243            dst_subresource: ImageSubresourceLayers::default(),
45244            dst_offsets: unsafe { ::std::mem::zeroed() },
45245        }
45246    }
45247}
45248impl ImageBlit2 {
45249    pub fn builder<'a>() -> ImageBlit2Builder<'a> {
45250        ImageBlit2Builder {
45251            inner: Self::default(),
45252            marker: ::std::marker::PhantomData,
45253        }
45254    }
45255}
45256#[repr(transparent)]
45257pub struct ImageBlit2Builder<'a> {
45258    inner: ImageBlit2,
45259    marker: ::std::marker::PhantomData<&'a ()>,
45260}
45261pub unsafe trait ExtendsImageBlit2 {}
45262impl<'a> ::std::ops::Deref for ImageBlit2Builder<'a> {
45263    type Target = ImageBlit2;
45264    fn deref(&self) -> &Self::Target {
45265        &self.inner
45266    }
45267}
45268impl<'a> ::std::ops::DerefMut for ImageBlit2Builder<'a> {
45269    fn deref_mut(&mut self) -> &mut Self::Target {
45270        &mut self.inner
45271    }
45272}
45273impl<'a> ImageBlit2Builder<'a> {
45274    pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
45275        self.inner.src_subresource = src_subresource;
45276        self
45277    }
45278    pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
45279        self.inner.src_offsets = src_offsets;
45280        self
45281    }
45282    pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
45283        self.inner.dst_subresource = dst_subresource;
45284        self
45285    }
45286    pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
45287        self.inner.dst_offsets = dst_offsets;
45288        self
45289    }
45290    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45291    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45292    #[doc = r" valid extension structs can be pushed into the chain."]
45293    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45294    #[doc = r" chain will look like `A -> D -> B -> C`."]
45295    pub fn push_next<T: ExtendsImageBlit2>(mut self, next: &'a mut T) -> Self {
45296        unsafe {
45297            let next_ptr = <*const T>::cast(next);
45298            let last_next = ptr_chain_iter(next).last().unwrap();
45299            (*last_next).p_next = self.inner.p_next as _;
45300            self.inner.p_next = next_ptr;
45301        }
45302        self
45303    }
45304    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45305    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45306    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45307    pub fn build(self) -> ImageBlit2 {
45308        self.inner
45309    }
45310}
45311#[repr(C)]
45312#[cfg_attr(feature = "debug", derive(Debug))]
45313#[derive(Copy, Clone)]
45314#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy2.html>"]
45315pub struct BufferImageCopy2 {
45316    pub s_type: StructureType,
45317    pub p_next: *const c_void,
45318    pub buffer_offset: DeviceSize,
45319    pub buffer_row_length: u32,
45320    pub buffer_image_height: u32,
45321    pub image_subresource: ImageSubresourceLayers,
45322    pub image_offset: Offset3D,
45323    pub image_extent: Extent3D,
45324}
45325impl ::std::default::Default for BufferImageCopy2 {
45326    fn default() -> Self {
45327        Self {
45328            s_type: StructureType::BUFFER_IMAGE_COPY_2,
45329            p_next: ::std::ptr::null(),
45330            buffer_offset: DeviceSize::default(),
45331            buffer_row_length: u32::default(),
45332            buffer_image_height: u32::default(),
45333            image_subresource: ImageSubresourceLayers::default(),
45334            image_offset: Offset3D::default(),
45335            image_extent: Extent3D::default(),
45336        }
45337    }
45338}
45339impl BufferImageCopy2 {
45340    pub fn builder<'a>() -> BufferImageCopy2Builder<'a> {
45341        BufferImageCopy2Builder {
45342            inner: Self::default(),
45343            marker: ::std::marker::PhantomData,
45344        }
45345    }
45346}
45347#[repr(transparent)]
45348pub struct BufferImageCopy2Builder<'a> {
45349    inner: BufferImageCopy2,
45350    marker: ::std::marker::PhantomData<&'a ()>,
45351}
45352pub unsafe trait ExtendsBufferImageCopy2 {}
45353impl<'a> ::std::ops::Deref for BufferImageCopy2Builder<'a> {
45354    type Target = BufferImageCopy2;
45355    fn deref(&self) -> &Self::Target {
45356        &self.inner
45357    }
45358}
45359impl<'a> ::std::ops::DerefMut for BufferImageCopy2Builder<'a> {
45360    fn deref_mut(&mut self) -> &mut Self::Target {
45361        &mut self.inner
45362    }
45363}
45364impl<'a> BufferImageCopy2Builder<'a> {
45365    pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
45366        self.inner.buffer_offset = buffer_offset;
45367        self
45368    }
45369    pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
45370        self.inner.buffer_row_length = buffer_row_length;
45371        self
45372    }
45373    pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
45374        self.inner.buffer_image_height = buffer_image_height;
45375        self
45376    }
45377    pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
45378        self.inner.image_subresource = image_subresource;
45379        self
45380    }
45381    pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
45382        self.inner.image_offset = image_offset;
45383        self
45384    }
45385    pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
45386        self.inner.image_extent = image_extent;
45387        self
45388    }
45389    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45390    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45391    #[doc = r" valid extension structs can be pushed into the chain."]
45392    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45393    #[doc = r" chain will look like `A -> D -> B -> C`."]
45394    pub fn push_next<T: ExtendsBufferImageCopy2>(mut self, next: &'a mut T) -> Self {
45395        unsafe {
45396            let next_ptr = <*const T>::cast(next);
45397            let last_next = ptr_chain_iter(next).last().unwrap();
45398            (*last_next).p_next = self.inner.p_next as _;
45399            self.inner.p_next = next_ptr;
45400        }
45401        self
45402    }
45403    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45404    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45405    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45406    pub fn build(self) -> BufferImageCopy2 {
45407        self.inner
45408    }
45409}
45410#[repr(C)]
45411#[cfg_attr(feature = "debug", derive(Debug))]
45412#[derive(Copy, Clone)]
45413#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve2.html>"]
45414pub struct ImageResolve2 {
45415    pub s_type: StructureType,
45416    pub p_next: *const c_void,
45417    pub src_subresource: ImageSubresourceLayers,
45418    pub src_offset: Offset3D,
45419    pub dst_subresource: ImageSubresourceLayers,
45420    pub dst_offset: Offset3D,
45421    pub extent: Extent3D,
45422}
45423impl ::std::default::Default for ImageResolve2 {
45424    fn default() -> Self {
45425        Self {
45426            s_type: StructureType::IMAGE_RESOLVE_2,
45427            p_next: ::std::ptr::null(),
45428            src_subresource: ImageSubresourceLayers::default(),
45429            src_offset: Offset3D::default(),
45430            dst_subresource: ImageSubresourceLayers::default(),
45431            dst_offset: Offset3D::default(),
45432            extent: Extent3D::default(),
45433        }
45434    }
45435}
45436impl ImageResolve2 {
45437    pub fn builder<'a>() -> ImageResolve2Builder<'a> {
45438        ImageResolve2Builder {
45439            inner: Self::default(),
45440            marker: ::std::marker::PhantomData,
45441        }
45442    }
45443}
45444#[repr(transparent)]
45445pub struct ImageResolve2Builder<'a> {
45446    inner: ImageResolve2,
45447    marker: ::std::marker::PhantomData<&'a ()>,
45448}
45449impl<'a> ::std::ops::Deref for ImageResolve2Builder<'a> {
45450    type Target = ImageResolve2;
45451    fn deref(&self) -> &Self::Target {
45452        &self.inner
45453    }
45454}
45455impl<'a> ::std::ops::DerefMut for ImageResolve2Builder<'a> {
45456    fn deref_mut(&mut self) -> &mut Self::Target {
45457        &mut self.inner
45458    }
45459}
45460impl<'a> ImageResolve2Builder<'a> {
45461    pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
45462        self.inner.src_subresource = src_subresource;
45463        self
45464    }
45465    pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
45466        self.inner.src_offset = src_offset;
45467        self
45468    }
45469    pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
45470        self.inner.dst_subresource = dst_subresource;
45471        self
45472    }
45473    pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
45474        self.inner.dst_offset = dst_offset;
45475        self
45476    }
45477    pub fn extent(mut self, extent: Extent3D) -> Self {
45478        self.inner.extent = extent;
45479        self
45480    }
45481    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45482    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45483    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45484    pub fn build(self) -> ImageResolve2 {
45485        self.inner
45486    }
45487}
45488#[repr(C)]
45489#[cfg_attr(feature = "debug", derive(Debug))]
45490#[derive(Copy, Clone)]
45491#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferInfo2.html>"]
45492pub struct CopyBufferInfo2 {
45493    pub s_type: StructureType,
45494    pub p_next: *const c_void,
45495    pub src_buffer: Buffer,
45496    pub dst_buffer: Buffer,
45497    pub region_count: u32,
45498    pub p_regions: *const BufferCopy2,
45499}
45500impl ::std::default::Default for CopyBufferInfo2 {
45501    fn default() -> Self {
45502        Self {
45503            s_type: StructureType::COPY_BUFFER_INFO_2,
45504            p_next: ::std::ptr::null(),
45505            src_buffer: Buffer::default(),
45506            dst_buffer: Buffer::default(),
45507            region_count: u32::default(),
45508            p_regions: ::std::ptr::null(),
45509        }
45510    }
45511}
45512impl CopyBufferInfo2 {
45513    pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> {
45514        CopyBufferInfo2Builder {
45515            inner: Self::default(),
45516            marker: ::std::marker::PhantomData,
45517        }
45518    }
45519}
45520#[repr(transparent)]
45521pub struct CopyBufferInfo2Builder<'a> {
45522    inner: CopyBufferInfo2,
45523    marker: ::std::marker::PhantomData<&'a ()>,
45524}
45525impl<'a> ::std::ops::Deref for CopyBufferInfo2Builder<'a> {
45526    type Target = CopyBufferInfo2;
45527    fn deref(&self) -> &Self::Target {
45528        &self.inner
45529    }
45530}
45531impl<'a> ::std::ops::DerefMut for CopyBufferInfo2Builder<'a> {
45532    fn deref_mut(&mut self) -> &mut Self::Target {
45533        &mut self.inner
45534    }
45535}
45536impl<'a> CopyBufferInfo2Builder<'a> {
45537    pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
45538        self.inner.src_buffer = src_buffer;
45539        self
45540    }
45541    pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
45542        self.inner.dst_buffer = dst_buffer;
45543        self
45544    }
45545    pub fn regions(mut self, regions: &'a [BufferCopy2]) -> Self {
45546        self.inner.region_count = regions.len() as _;
45547        self.inner.p_regions = regions.as_ptr();
45548        self
45549    }
45550    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45551    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45552    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45553    pub fn build(self) -> CopyBufferInfo2 {
45554        self.inner
45555    }
45556}
45557#[repr(C)]
45558#[cfg_attr(feature = "debug", derive(Debug))]
45559#[derive(Copy, Clone)]
45560#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageInfo2.html>"]
45561pub struct CopyImageInfo2 {
45562    pub s_type: StructureType,
45563    pub p_next: *const c_void,
45564    pub src_image: Image,
45565    pub src_image_layout: ImageLayout,
45566    pub dst_image: Image,
45567    pub dst_image_layout: ImageLayout,
45568    pub region_count: u32,
45569    pub p_regions: *const ImageCopy2,
45570}
45571impl ::std::default::Default for CopyImageInfo2 {
45572    fn default() -> Self {
45573        Self {
45574            s_type: StructureType::COPY_IMAGE_INFO_2,
45575            p_next: ::std::ptr::null(),
45576            src_image: Image::default(),
45577            src_image_layout: ImageLayout::default(),
45578            dst_image: Image::default(),
45579            dst_image_layout: ImageLayout::default(),
45580            region_count: u32::default(),
45581            p_regions: ::std::ptr::null(),
45582        }
45583    }
45584}
45585impl CopyImageInfo2 {
45586    pub fn builder<'a>() -> CopyImageInfo2Builder<'a> {
45587        CopyImageInfo2Builder {
45588            inner: Self::default(),
45589            marker: ::std::marker::PhantomData,
45590        }
45591    }
45592}
45593#[repr(transparent)]
45594pub struct CopyImageInfo2Builder<'a> {
45595    inner: CopyImageInfo2,
45596    marker: ::std::marker::PhantomData<&'a ()>,
45597}
45598impl<'a> ::std::ops::Deref for CopyImageInfo2Builder<'a> {
45599    type Target = CopyImageInfo2;
45600    fn deref(&self) -> &Self::Target {
45601        &self.inner
45602    }
45603}
45604impl<'a> ::std::ops::DerefMut for CopyImageInfo2Builder<'a> {
45605    fn deref_mut(&mut self) -> &mut Self::Target {
45606        &mut self.inner
45607    }
45608}
45609impl<'a> CopyImageInfo2Builder<'a> {
45610    pub fn src_image(mut self, src_image: Image) -> Self {
45611        self.inner.src_image = src_image;
45612        self
45613    }
45614    pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45615        self.inner.src_image_layout = src_image_layout;
45616        self
45617    }
45618    pub fn dst_image(mut self, dst_image: Image) -> Self {
45619        self.inner.dst_image = dst_image;
45620        self
45621    }
45622    pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45623        self.inner.dst_image_layout = dst_image_layout;
45624        self
45625    }
45626    pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self {
45627        self.inner.region_count = regions.len() as _;
45628        self.inner.p_regions = regions.as_ptr();
45629        self
45630    }
45631    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45632    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45633    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45634    pub fn build(self) -> CopyImageInfo2 {
45635        self.inner
45636    }
45637}
45638#[repr(C)]
45639#[cfg_attr(feature = "debug", derive(Debug))]
45640#[derive(Copy, Clone)]
45641#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlitImageInfo2.html>"]
45642pub struct BlitImageInfo2 {
45643    pub s_type: StructureType,
45644    pub p_next: *const c_void,
45645    pub src_image: Image,
45646    pub src_image_layout: ImageLayout,
45647    pub dst_image: Image,
45648    pub dst_image_layout: ImageLayout,
45649    pub region_count: u32,
45650    pub p_regions: *const ImageBlit2,
45651    pub filter: Filter,
45652}
45653impl ::std::default::Default for BlitImageInfo2 {
45654    fn default() -> Self {
45655        Self {
45656            s_type: StructureType::BLIT_IMAGE_INFO_2,
45657            p_next: ::std::ptr::null(),
45658            src_image: Image::default(),
45659            src_image_layout: ImageLayout::default(),
45660            dst_image: Image::default(),
45661            dst_image_layout: ImageLayout::default(),
45662            region_count: u32::default(),
45663            p_regions: ::std::ptr::null(),
45664            filter: Filter::default(),
45665        }
45666    }
45667}
45668impl BlitImageInfo2 {
45669    pub fn builder<'a>() -> BlitImageInfo2Builder<'a> {
45670        BlitImageInfo2Builder {
45671            inner: Self::default(),
45672            marker: ::std::marker::PhantomData,
45673        }
45674    }
45675}
45676#[repr(transparent)]
45677pub struct BlitImageInfo2Builder<'a> {
45678    inner: BlitImageInfo2,
45679    marker: ::std::marker::PhantomData<&'a ()>,
45680}
45681impl<'a> ::std::ops::Deref for BlitImageInfo2Builder<'a> {
45682    type Target = BlitImageInfo2;
45683    fn deref(&self) -> &Self::Target {
45684        &self.inner
45685    }
45686}
45687impl<'a> ::std::ops::DerefMut for BlitImageInfo2Builder<'a> {
45688    fn deref_mut(&mut self) -> &mut Self::Target {
45689        &mut self.inner
45690    }
45691}
45692impl<'a> BlitImageInfo2Builder<'a> {
45693    pub fn src_image(mut self, src_image: Image) -> Self {
45694        self.inner.src_image = src_image;
45695        self
45696    }
45697    pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45698        self.inner.src_image_layout = src_image_layout;
45699        self
45700    }
45701    pub fn dst_image(mut self, dst_image: Image) -> Self {
45702        self.inner.dst_image = dst_image;
45703        self
45704    }
45705    pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45706        self.inner.dst_image_layout = dst_image_layout;
45707        self
45708    }
45709    pub fn regions(mut self, regions: &'a [ImageBlit2]) -> Self {
45710        self.inner.region_count = regions.len() as _;
45711        self.inner.p_regions = regions.as_ptr();
45712        self
45713    }
45714    pub fn filter(mut self, filter: Filter) -> Self {
45715        self.inner.filter = filter;
45716        self
45717    }
45718    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45719    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45720    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45721    pub fn build(self) -> BlitImageInfo2 {
45722        self.inner
45723    }
45724}
45725#[repr(C)]
45726#[cfg_attr(feature = "debug", derive(Debug))]
45727#[derive(Copy, Clone)]
45728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferToImageInfo2.html>"]
45729pub struct CopyBufferToImageInfo2 {
45730    pub s_type: StructureType,
45731    pub p_next: *const c_void,
45732    pub src_buffer: Buffer,
45733    pub dst_image: Image,
45734    pub dst_image_layout: ImageLayout,
45735    pub region_count: u32,
45736    pub p_regions: *const BufferImageCopy2,
45737}
45738impl ::std::default::Default for CopyBufferToImageInfo2 {
45739    fn default() -> Self {
45740        Self {
45741            s_type: StructureType::COPY_BUFFER_TO_IMAGE_INFO_2,
45742            p_next: ::std::ptr::null(),
45743            src_buffer: Buffer::default(),
45744            dst_image: Image::default(),
45745            dst_image_layout: ImageLayout::default(),
45746            region_count: u32::default(),
45747            p_regions: ::std::ptr::null(),
45748        }
45749    }
45750}
45751impl CopyBufferToImageInfo2 {
45752    pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> {
45753        CopyBufferToImageInfo2Builder {
45754            inner: Self::default(),
45755            marker: ::std::marker::PhantomData,
45756        }
45757    }
45758}
45759#[repr(transparent)]
45760pub struct CopyBufferToImageInfo2Builder<'a> {
45761    inner: CopyBufferToImageInfo2,
45762    marker: ::std::marker::PhantomData<&'a ()>,
45763}
45764impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2Builder<'a> {
45765    type Target = CopyBufferToImageInfo2;
45766    fn deref(&self) -> &Self::Target {
45767        &self.inner
45768    }
45769}
45770impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> {
45771    fn deref_mut(&mut self) -> &mut Self::Target {
45772        &mut self.inner
45773    }
45774}
45775impl<'a> CopyBufferToImageInfo2Builder<'a> {
45776    pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
45777        self.inner.src_buffer = src_buffer;
45778        self
45779    }
45780    pub fn dst_image(mut self, dst_image: Image) -> Self {
45781        self.inner.dst_image = dst_image;
45782        self
45783    }
45784    pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45785        self.inner.dst_image_layout = dst_image_layout;
45786        self
45787    }
45788    pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
45789        self.inner.region_count = regions.len() as _;
45790        self.inner.p_regions = regions.as_ptr();
45791        self
45792    }
45793    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45794    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45795    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45796    pub fn build(self) -> CopyBufferToImageInfo2 {
45797        self.inner
45798    }
45799}
45800#[repr(C)]
45801#[cfg_attr(feature = "debug", derive(Debug))]
45802#[derive(Copy, Clone)]
45803#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToBufferInfo2.html>"]
45804pub struct CopyImageToBufferInfo2 {
45805    pub s_type: StructureType,
45806    pub p_next: *const c_void,
45807    pub src_image: Image,
45808    pub src_image_layout: ImageLayout,
45809    pub dst_buffer: Buffer,
45810    pub region_count: u32,
45811    pub p_regions: *const BufferImageCopy2,
45812}
45813impl ::std::default::Default for CopyImageToBufferInfo2 {
45814    fn default() -> Self {
45815        Self {
45816            s_type: StructureType::COPY_IMAGE_TO_BUFFER_INFO_2,
45817            p_next: ::std::ptr::null(),
45818            src_image: Image::default(),
45819            src_image_layout: ImageLayout::default(),
45820            dst_buffer: Buffer::default(),
45821            region_count: u32::default(),
45822            p_regions: ::std::ptr::null(),
45823        }
45824    }
45825}
45826impl CopyImageToBufferInfo2 {
45827    pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> {
45828        CopyImageToBufferInfo2Builder {
45829            inner: Self::default(),
45830            marker: ::std::marker::PhantomData,
45831        }
45832    }
45833}
45834#[repr(transparent)]
45835pub struct CopyImageToBufferInfo2Builder<'a> {
45836    inner: CopyImageToBufferInfo2,
45837    marker: ::std::marker::PhantomData<&'a ()>,
45838}
45839impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2Builder<'a> {
45840    type Target = CopyImageToBufferInfo2;
45841    fn deref(&self) -> &Self::Target {
45842        &self.inner
45843    }
45844}
45845impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> {
45846    fn deref_mut(&mut self) -> &mut Self::Target {
45847        &mut self.inner
45848    }
45849}
45850impl<'a> CopyImageToBufferInfo2Builder<'a> {
45851    pub fn src_image(mut self, src_image: Image) -> Self {
45852        self.inner.src_image = src_image;
45853        self
45854    }
45855    pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45856        self.inner.src_image_layout = src_image_layout;
45857        self
45858    }
45859    pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
45860        self.inner.dst_buffer = dst_buffer;
45861        self
45862    }
45863    pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
45864        self.inner.region_count = regions.len() as _;
45865        self.inner.p_regions = regions.as_ptr();
45866        self
45867    }
45868    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45869    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45870    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45871    pub fn build(self) -> CopyImageToBufferInfo2 {
45872        self.inner
45873    }
45874}
45875#[repr(C)]
45876#[cfg_attr(feature = "debug", derive(Debug))]
45877#[derive(Copy, Clone)]
45878#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveImageInfo2.html>"]
45879pub struct ResolveImageInfo2 {
45880    pub s_type: StructureType,
45881    pub p_next: *const c_void,
45882    pub src_image: Image,
45883    pub src_image_layout: ImageLayout,
45884    pub dst_image: Image,
45885    pub dst_image_layout: ImageLayout,
45886    pub region_count: u32,
45887    pub p_regions: *const ImageResolve2,
45888}
45889impl ::std::default::Default for ResolveImageInfo2 {
45890    fn default() -> Self {
45891        Self {
45892            s_type: StructureType::RESOLVE_IMAGE_INFO_2,
45893            p_next: ::std::ptr::null(),
45894            src_image: Image::default(),
45895            src_image_layout: ImageLayout::default(),
45896            dst_image: Image::default(),
45897            dst_image_layout: ImageLayout::default(),
45898            region_count: u32::default(),
45899            p_regions: ::std::ptr::null(),
45900        }
45901    }
45902}
45903impl ResolveImageInfo2 {
45904    pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> {
45905        ResolveImageInfo2Builder {
45906            inner: Self::default(),
45907            marker: ::std::marker::PhantomData,
45908        }
45909    }
45910}
45911#[repr(transparent)]
45912pub struct ResolveImageInfo2Builder<'a> {
45913    inner: ResolveImageInfo2,
45914    marker: ::std::marker::PhantomData<&'a ()>,
45915}
45916impl<'a> ::std::ops::Deref for ResolveImageInfo2Builder<'a> {
45917    type Target = ResolveImageInfo2;
45918    fn deref(&self) -> &Self::Target {
45919        &self.inner
45920    }
45921}
45922impl<'a> ::std::ops::DerefMut for ResolveImageInfo2Builder<'a> {
45923    fn deref_mut(&mut self) -> &mut Self::Target {
45924        &mut self.inner
45925    }
45926}
45927impl<'a> ResolveImageInfo2Builder<'a> {
45928    pub fn src_image(mut self, src_image: Image) -> Self {
45929        self.inner.src_image = src_image;
45930        self
45931    }
45932    pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
45933        self.inner.src_image_layout = src_image_layout;
45934        self
45935    }
45936    pub fn dst_image(mut self, dst_image: Image) -> Self {
45937        self.inner.dst_image = dst_image;
45938        self
45939    }
45940    pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
45941        self.inner.dst_image_layout = dst_image_layout;
45942        self
45943    }
45944    pub fn regions(mut self, regions: &'a [ImageResolve2]) -> Self {
45945        self.inner.region_count = regions.len() as _;
45946        self.inner.p_regions = regions.as_ptr();
45947        self
45948    }
45949    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45950    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45951    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
45952    pub fn build(self) -> ResolveImageInfo2 {
45953        self.inner
45954    }
45955}
45956#[repr(C)]
45957#[cfg_attr(feature = "debug", derive(Debug))]
45958#[derive(Copy, Clone)]
45959#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html>"]
45960pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
45961    pub s_type: StructureType,
45962    pub p_next: *mut c_void,
45963    pub shader_image_int64_atomics: Bool32,
45964    pub sparse_image_int64_atomics: Bool32,
45965}
45966impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
45967    fn default() -> Self {
45968        Self {
45969            s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
45970            p_next: ::std::ptr::null_mut(),
45971            shader_image_int64_atomics: Bool32::default(),
45972            sparse_image_int64_atomics: Bool32::default(),
45973        }
45974    }
45975}
45976impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
45977    pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
45978        PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder {
45979            inner: Self::default(),
45980            marker: ::std::marker::PhantomData,
45981        }
45982    }
45983}
45984#[repr(transparent)]
45985pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
45986    inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT,
45987    marker: ::std::marker::PhantomData<&'a ()>,
45988}
45989unsafe impl ExtendsPhysicalDeviceFeatures2
45990    for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_>
45991{
45992}
45993unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {}
45994unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {}
45995unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {}
45996impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
45997    type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
45998    fn deref(&self) -> &Self::Target {
45999        &self.inner
46000    }
46001}
46002impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
46003    fn deref_mut(&mut self) -> &mut Self::Target {
46004        &mut self.inner
46005    }
46006}
46007impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
46008    pub fn shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self {
46009        self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into();
46010        self
46011    }
46012    pub fn sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self {
46013        self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into();
46014        self
46015    }
46016    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46017    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46018    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46019    pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
46020        self.inner
46021    }
46022}
46023#[repr(C)]
46024#[cfg_attr(feature = "debug", derive(Debug))]
46025#[derive(Copy, Clone)]
46026#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateAttachmentInfoKHR.html>"]
46027pub struct FragmentShadingRateAttachmentInfoKHR {
46028    pub s_type: StructureType,
46029    pub p_next: *const c_void,
46030    pub p_fragment_shading_rate_attachment: *const AttachmentReference2,
46031    pub shading_rate_attachment_texel_size: Extent2D,
46032}
46033impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR {
46034    fn default() -> Self {
46035        Self {
46036            s_type: StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
46037            p_next: ::std::ptr::null(),
46038            p_fragment_shading_rate_attachment: ::std::ptr::null(),
46039            shading_rate_attachment_texel_size: Extent2D::default(),
46040        }
46041    }
46042}
46043impl FragmentShadingRateAttachmentInfoKHR {
46044    pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46045        FragmentShadingRateAttachmentInfoKHRBuilder {
46046            inner: Self::default(),
46047            marker: ::std::marker::PhantomData,
46048        }
46049    }
46050}
46051#[repr(transparent)]
46052pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46053    inner: FragmentShadingRateAttachmentInfoKHR,
46054    marker: ::std::marker::PhantomData<&'a ()>,
46055}
46056unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
46057unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {}
46058impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46059    type Target = FragmentShadingRateAttachmentInfoKHR;
46060    fn deref(&self) -> &Self::Target {
46061        &self.inner
46062    }
46063}
46064impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46065    fn deref_mut(&mut self) -> &mut Self::Target {
46066        &mut self.inner
46067    }
46068}
46069impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
46070    pub fn fragment_shading_rate_attachment(
46071        mut self,
46072        fragment_shading_rate_attachment: &'a AttachmentReference2,
46073    ) -> Self {
46074        self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment;
46075        self
46076    }
46077    pub fn shading_rate_attachment_texel_size(
46078        mut self,
46079        shading_rate_attachment_texel_size: Extent2D,
46080    ) -> Self {
46081        self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
46082        self
46083    }
46084    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46085    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46086    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46087    pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR {
46088        self.inner
46089    }
46090}
46091#[repr(C)]
46092#[cfg_attr(feature = "debug", derive(Debug))]
46093#[derive(Copy, Clone)]
46094#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html>"]
46095pub struct PipelineFragmentShadingRateStateCreateInfoKHR {
46096    pub s_type: StructureType,
46097    pub p_next: *const c_void,
46098    pub fragment_size: Extent2D,
46099    pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
46100}
46101impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR {
46102    fn default() -> Self {
46103        Self {
46104            s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
46105            p_next: ::std::ptr::null(),
46106            fragment_size: Extent2D::default(),
46107            combiner_ops: unsafe { ::std::mem::zeroed() },
46108        }
46109    }
46110}
46111impl PipelineFragmentShadingRateStateCreateInfoKHR {
46112    pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46113        PipelineFragmentShadingRateStateCreateInfoKHRBuilder {
46114            inner: Self::default(),
46115            marker: ::std::marker::PhantomData,
46116        }
46117    }
46118}
46119#[repr(transparent)]
46120pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46121    inner: PipelineFragmentShadingRateStateCreateInfoKHR,
46122    marker: ::std::marker::PhantomData<&'a ()>,
46123}
46124unsafe impl ExtendsGraphicsPipelineCreateInfo
46125    for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_>
46126{
46127}
46128unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {}
46129impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46130    type Target = PipelineFragmentShadingRateStateCreateInfoKHR;
46131    fn deref(&self) -> &Self::Target {
46132        &self.inner
46133    }
46134}
46135impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46136    fn deref_mut(&mut self) -> &mut Self::Target {
46137        &mut self.inner
46138    }
46139}
46140impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
46141    pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
46142        self.inner.fragment_size = fragment_size;
46143        self
46144    }
46145    pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
46146        self.inner.combiner_ops = combiner_ops;
46147        self
46148    }
46149    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46150    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46151    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46152    pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR {
46153        self.inner
46154    }
46155}
46156#[repr(C)]
46157#[cfg_attr(feature = "debug", derive(Debug))]
46158#[derive(Copy, Clone)]
46159#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html>"]
46160pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
46161    pub s_type: StructureType,
46162    pub p_next: *mut c_void,
46163    pub pipeline_fragment_shading_rate: Bool32,
46164    pub primitive_fragment_shading_rate: Bool32,
46165    pub attachment_fragment_shading_rate: Bool32,
46166}
46167impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR {
46168    fn default() -> Self {
46169        Self {
46170            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,
46171            p_next: ::std::ptr::null_mut(),
46172            pipeline_fragment_shading_rate: Bool32::default(),
46173            primitive_fragment_shading_rate: Bool32::default(),
46174            attachment_fragment_shading_rate: Bool32::default(),
46175        }
46176    }
46177}
46178impl PhysicalDeviceFragmentShadingRateFeaturesKHR {
46179    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46180        PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder {
46181            inner: Self::default(),
46182            marker: ::std::marker::PhantomData,
46183        }
46184    }
46185}
46186#[repr(transparent)]
46187pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46188    inner: PhysicalDeviceFragmentShadingRateFeaturesKHR,
46189    marker: ::std::marker::PhantomData<&'a ()>,
46190}
46191unsafe impl ExtendsPhysicalDeviceFeatures2
46192    for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_>
46193{
46194}
46195unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR {}
46196unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {}
46197unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {}
46198impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46199    type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR;
46200    fn deref(&self) -> &Self::Target {
46201        &self.inner
46202    }
46203}
46204impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46205    fn deref_mut(&mut self) -> &mut Self::Target {
46206        &mut self.inner
46207    }
46208}
46209impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
46210    pub fn pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self {
46211        self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into();
46212        self
46213    }
46214    pub fn primitive_fragment_shading_rate(
46215        mut self,
46216        primitive_fragment_shading_rate: bool,
46217    ) -> Self {
46218        self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into();
46219        self
46220    }
46221    pub fn attachment_fragment_shading_rate(
46222        mut self,
46223        attachment_fragment_shading_rate: bool,
46224    ) -> Self {
46225        self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into();
46226        self
46227    }
46228    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46229    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46230    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46231    pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR {
46232        self.inner
46233    }
46234}
46235#[repr(C)]
46236#[cfg_attr(feature = "debug", derive(Debug))]
46237#[derive(Copy, Clone)]
46238#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html>"]
46239pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
46240    pub s_type: StructureType,
46241    pub p_next: *mut c_void,
46242    pub min_fragment_shading_rate_attachment_texel_size: Extent2D,
46243    pub max_fragment_shading_rate_attachment_texel_size: Extent2D,
46244    pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
46245    pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32,
46246    pub layered_shading_rate_attachments: Bool32,
46247    pub fragment_shading_rate_non_trivial_combiner_ops: Bool32,
46248    pub max_fragment_size: Extent2D,
46249    pub max_fragment_size_aspect_ratio: u32,
46250    pub max_fragment_shading_rate_coverage_samples: u32,
46251    pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
46252    pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32,
46253    pub fragment_shading_rate_with_sample_mask: Bool32,
46254    pub fragment_shading_rate_with_shader_sample_mask: Bool32,
46255    pub fragment_shading_rate_with_conservative_rasterization: Bool32,
46256    pub fragment_shading_rate_with_fragment_shader_interlock: Bool32,
46257    pub fragment_shading_rate_with_custom_sample_locations: Bool32,
46258    pub fragment_shading_rate_strict_multiply_combiner: Bool32,
46259}
46260impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR {
46261    fn default() -> Self {
46262        Self {
46263            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR,
46264            p_next: ::std::ptr::null_mut(),
46265            min_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
46266            max_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
46267            max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(),
46268            primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(),
46269            layered_shading_rate_attachments: Bool32::default(),
46270            fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(),
46271            max_fragment_size: Extent2D::default(),
46272            max_fragment_size_aspect_ratio: u32::default(),
46273            max_fragment_shading_rate_coverage_samples: u32::default(),
46274            max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(),
46275            fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(),
46276            fragment_shading_rate_with_sample_mask: Bool32::default(),
46277            fragment_shading_rate_with_shader_sample_mask: Bool32::default(),
46278            fragment_shading_rate_with_conservative_rasterization: Bool32::default(),
46279            fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(),
46280            fragment_shading_rate_with_custom_sample_locations: Bool32::default(),
46281            fragment_shading_rate_strict_multiply_combiner: Bool32::default(),
46282        }
46283    }
46284}
46285impl PhysicalDeviceFragmentShadingRatePropertiesKHR {
46286    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46287        PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder {
46288            inner: Self::default(),
46289            marker: ::std::marker::PhantomData,
46290        }
46291    }
46292}
46293#[repr(transparent)]
46294pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46295    inner: PhysicalDeviceFragmentShadingRatePropertiesKHR,
46296    marker: ::std::marker::PhantomData<&'a ()>,
46297}
46298unsafe impl ExtendsPhysicalDeviceProperties2
46299    for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_>
46300{
46301}
46302unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {}
46303impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46304    type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR;
46305    fn deref(&self) -> &Self::Target {
46306        &self.inner
46307    }
46308}
46309impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46310    fn deref_mut(&mut self) -> &mut Self::Target {
46311        &mut self.inner
46312    }
46313}
46314impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
46315    pub fn min_fragment_shading_rate_attachment_texel_size(
46316        mut self,
46317        min_fragment_shading_rate_attachment_texel_size: Extent2D,
46318    ) -> Self {
46319        self.inner.min_fragment_shading_rate_attachment_texel_size =
46320            min_fragment_shading_rate_attachment_texel_size;
46321        self
46322    }
46323    pub fn max_fragment_shading_rate_attachment_texel_size(
46324        mut self,
46325        max_fragment_shading_rate_attachment_texel_size: Extent2D,
46326    ) -> Self {
46327        self.inner.max_fragment_shading_rate_attachment_texel_size =
46328            max_fragment_shading_rate_attachment_texel_size;
46329        self
46330    }
46331    pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio(
46332        mut self,
46333        max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
46334    ) -> Self {
46335        self.inner
46336            .max_fragment_shading_rate_attachment_texel_size_aspect_ratio =
46337            max_fragment_shading_rate_attachment_texel_size_aspect_ratio;
46338        self
46339    }
46340    pub fn primitive_fragment_shading_rate_with_multiple_viewports(
46341        mut self,
46342        primitive_fragment_shading_rate_with_multiple_viewports: bool,
46343    ) -> Self {
46344        self.inner
46345            .primitive_fragment_shading_rate_with_multiple_viewports =
46346            primitive_fragment_shading_rate_with_multiple_viewports.into();
46347        self
46348    }
46349    pub fn layered_shading_rate_attachments(
46350        mut self,
46351        layered_shading_rate_attachments: bool,
46352    ) -> Self {
46353        self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into();
46354        self
46355    }
46356    pub fn fragment_shading_rate_non_trivial_combiner_ops(
46357        mut self,
46358        fragment_shading_rate_non_trivial_combiner_ops: bool,
46359    ) -> Self {
46360        self.inner.fragment_shading_rate_non_trivial_combiner_ops =
46361            fragment_shading_rate_non_trivial_combiner_ops.into();
46362        self
46363    }
46364    pub fn max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self {
46365        self.inner.max_fragment_size = max_fragment_size;
46366        self
46367    }
46368    pub fn max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self {
46369        self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio;
46370        self
46371    }
46372    pub fn max_fragment_shading_rate_coverage_samples(
46373        mut self,
46374        max_fragment_shading_rate_coverage_samples: u32,
46375    ) -> Self {
46376        self.inner.max_fragment_shading_rate_coverage_samples =
46377            max_fragment_shading_rate_coverage_samples;
46378        self
46379    }
46380    pub fn max_fragment_shading_rate_rasterization_samples(
46381        mut self,
46382        max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
46383    ) -> Self {
46384        self.inner.max_fragment_shading_rate_rasterization_samples =
46385            max_fragment_shading_rate_rasterization_samples;
46386        self
46387    }
46388    pub fn fragment_shading_rate_with_shader_depth_stencil_writes(
46389        mut self,
46390        fragment_shading_rate_with_shader_depth_stencil_writes: bool,
46391    ) -> Self {
46392        self.inner
46393            .fragment_shading_rate_with_shader_depth_stencil_writes =
46394            fragment_shading_rate_with_shader_depth_stencil_writes.into();
46395        self
46396    }
46397    pub fn fragment_shading_rate_with_sample_mask(
46398        mut self,
46399        fragment_shading_rate_with_sample_mask: bool,
46400    ) -> Self {
46401        self.inner.fragment_shading_rate_with_sample_mask =
46402            fragment_shading_rate_with_sample_mask.into();
46403        self
46404    }
46405    pub fn fragment_shading_rate_with_shader_sample_mask(
46406        mut self,
46407        fragment_shading_rate_with_shader_sample_mask: bool,
46408    ) -> Self {
46409        self.inner.fragment_shading_rate_with_shader_sample_mask =
46410            fragment_shading_rate_with_shader_sample_mask.into();
46411        self
46412    }
46413    pub fn fragment_shading_rate_with_conservative_rasterization(
46414        mut self,
46415        fragment_shading_rate_with_conservative_rasterization: bool,
46416    ) -> Self {
46417        self.inner
46418            .fragment_shading_rate_with_conservative_rasterization =
46419            fragment_shading_rate_with_conservative_rasterization.into();
46420        self
46421    }
46422    pub fn fragment_shading_rate_with_fragment_shader_interlock(
46423        mut self,
46424        fragment_shading_rate_with_fragment_shader_interlock: bool,
46425    ) -> Self {
46426        self.inner
46427            .fragment_shading_rate_with_fragment_shader_interlock =
46428            fragment_shading_rate_with_fragment_shader_interlock.into();
46429        self
46430    }
46431    pub fn fragment_shading_rate_with_custom_sample_locations(
46432        mut self,
46433        fragment_shading_rate_with_custom_sample_locations: bool,
46434    ) -> Self {
46435        self.inner
46436            .fragment_shading_rate_with_custom_sample_locations =
46437            fragment_shading_rate_with_custom_sample_locations.into();
46438        self
46439    }
46440    pub fn fragment_shading_rate_strict_multiply_combiner(
46441        mut self,
46442        fragment_shading_rate_strict_multiply_combiner: bool,
46443    ) -> Self {
46444        self.inner.fragment_shading_rate_strict_multiply_combiner =
46445            fragment_shading_rate_strict_multiply_combiner.into();
46446        self
46447    }
46448    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46449    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46450    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46451    pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR {
46452        self.inner
46453    }
46454}
46455#[repr(C)]
46456#[cfg_attr(feature = "debug", derive(Debug))]
46457#[derive(Copy, Clone)]
46458#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html>"]
46459pub struct PhysicalDeviceFragmentShadingRateKHR {
46460    pub s_type: StructureType,
46461    pub p_next: *mut c_void,
46462    pub sample_counts: SampleCountFlags,
46463    pub fragment_size: Extent2D,
46464}
46465impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR {
46466    fn default() -> Self {
46467        Self {
46468            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
46469            p_next: ::std::ptr::null_mut(),
46470            sample_counts: SampleCountFlags::default(),
46471            fragment_size: Extent2D::default(),
46472        }
46473    }
46474}
46475impl PhysicalDeviceFragmentShadingRateKHR {
46476    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46477        PhysicalDeviceFragmentShadingRateKHRBuilder {
46478            inner: Self::default(),
46479            marker: ::std::marker::PhantomData,
46480        }
46481    }
46482}
46483#[repr(transparent)]
46484pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46485    inner: PhysicalDeviceFragmentShadingRateKHR,
46486    marker: ::std::marker::PhantomData<&'a ()>,
46487}
46488impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46489    type Target = PhysicalDeviceFragmentShadingRateKHR;
46490    fn deref(&self) -> &Self::Target {
46491        &self.inner
46492    }
46493}
46494impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46495    fn deref_mut(&mut self) -> &mut Self::Target {
46496        &mut self.inner
46497    }
46498}
46499impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
46500    pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
46501        self.inner.sample_counts = sample_counts;
46502        self
46503    }
46504    pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
46505        self.inner.fragment_size = fragment_size;
46506        self
46507    }
46508    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46509    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46510    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46511    pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR {
46512        self.inner
46513    }
46514}
46515#[repr(C)]
46516#[cfg_attr(feature = "debug", derive(Debug))]
46517#[derive(Copy, Clone)]
46518#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeatures.html>"]
46519pub struct PhysicalDeviceShaderTerminateInvocationFeatures {
46520    pub s_type: StructureType,
46521    pub p_next: *mut c_void,
46522    pub shader_terminate_invocation: Bool32,
46523}
46524impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures {
46525    fn default() -> Self {
46526        Self {
46527            s_type: StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES,
46528            p_next: ::std::ptr::null_mut(),
46529            shader_terminate_invocation: Bool32::default(),
46530        }
46531    }
46532}
46533impl PhysicalDeviceShaderTerminateInvocationFeatures {
46534    pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46535        PhysicalDeviceShaderTerminateInvocationFeaturesBuilder {
46536            inner: Self::default(),
46537            marker: ::std::marker::PhantomData,
46538        }
46539    }
46540}
46541#[repr(transparent)]
46542pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46543    inner: PhysicalDeviceShaderTerminateInvocationFeatures,
46544    marker: ::std::marker::PhantomData<&'a ()>,
46545}
46546unsafe impl ExtendsPhysicalDeviceFeatures2
46547    for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_>
46548{
46549}
46550unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures {}
46551unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> {}
46552unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures {}
46553impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46554    type Target = PhysicalDeviceShaderTerminateInvocationFeatures;
46555    fn deref(&self) -> &Self::Target {
46556        &self.inner
46557    }
46558}
46559impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46560    fn deref_mut(&mut self) -> &mut Self::Target {
46561        &mut self.inner
46562    }
46563}
46564impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
46565    pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
46566        self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
46567        self
46568    }
46569    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46570    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46571    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46572    pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures {
46573        self.inner
46574    }
46575}
46576#[repr(C)]
46577#[cfg_attr(feature = "debug", derive(Debug))]
46578#[derive(Copy, Clone)]
46579#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html>"]
46580pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46581    pub s_type: StructureType,
46582    pub p_next: *mut c_void,
46583    pub fragment_shading_rate_enums: Bool32,
46584    pub supersample_fragment_shading_rates: Bool32,
46585    pub no_invocation_fragment_shading_rates: Bool32,
46586}
46587impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46588    fn default() -> Self {
46589        Self {
46590            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV,
46591            p_next: ::std::ptr::null_mut(),
46592            fragment_shading_rate_enums: Bool32::default(),
46593            supersample_fragment_shading_rates: Bool32::default(),
46594            no_invocation_fragment_shading_rates: Bool32::default(),
46595        }
46596    }
46597}
46598impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46599    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46600        PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder {
46601            inner: Self::default(),
46602            marker: ::std::marker::PhantomData,
46603        }
46604    }
46605}
46606#[repr(transparent)]
46607pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46608    inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV,
46609    marker: ::std::marker::PhantomData<&'a ()>,
46610}
46611unsafe impl ExtendsPhysicalDeviceFeatures2
46612    for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_>
46613{
46614}
46615unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {}
46616unsafe impl ExtendsDeviceCreateInfo
46617    for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_>
46618{
46619}
46620unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {}
46621impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46622    type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
46623    fn deref(&self) -> &Self::Target {
46624        &self.inner
46625    }
46626}
46627impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46628    fn deref_mut(&mut self) -> &mut Self::Target {
46629        &mut self.inner
46630    }
46631}
46632impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
46633    pub fn fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self {
46634        self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into();
46635        self
46636    }
46637    pub fn supersample_fragment_shading_rates(
46638        mut self,
46639        supersample_fragment_shading_rates: bool,
46640    ) -> Self {
46641        self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into();
46642        self
46643    }
46644    pub fn no_invocation_fragment_shading_rates(
46645        mut self,
46646        no_invocation_fragment_shading_rates: bool,
46647    ) -> Self {
46648        self.inner.no_invocation_fragment_shading_rates =
46649            no_invocation_fragment_shading_rates.into();
46650        self
46651    }
46652    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46653    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46654    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46655    pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
46656        self.inner
46657    }
46658}
46659#[repr(C)]
46660#[cfg_attr(feature = "debug", derive(Debug))]
46661#[derive(Copy, Clone)]
46662#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html>"]
46663pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46664    pub s_type: StructureType,
46665    pub p_next: *mut c_void,
46666    pub max_fragment_shading_rate_invocation_count: SampleCountFlags,
46667}
46668impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46669    fn default() -> Self {
46670        Self {
46671            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV,
46672            p_next: ::std::ptr::null_mut(),
46673            max_fragment_shading_rate_invocation_count: SampleCountFlags::default(),
46674        }
46675    }
46676}
46677impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46678    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46679        PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder {
46680            inner: Self::default(),
46681            marker: ::std::marker::PhantomData,
46682        }
46683    }
46684}
46685#[repr(transparent)]
46686pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46687    inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV,
46688    marker: ::std::marker::PhantomData<&'a ()>,
46689}
46690unsafe impl ExtendsPhysicalDeviceProperties2
46691    for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_>
46692{
46693}
46694unsafe impl ExtendsPhysicalDeviceProperties2
46695    for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
46696{
46697}
46698impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46699    type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
46700    fn deref(&self) -> &Self::Target {
46701        &self.inner
46702    }
46703}
46704impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46705    fn deref_mut(&mut self) -> &mut Self::Target {
46706        &mut self.inner
46707    }
46708}
46709impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
46710    pub fn max_fragment_shading_rate_invocation_count(
46711        mut self,
46712        max_fragment_shading_rate_invocation_count: SampleCountFlags,
46713    ) -> Self {
46714        self.inner.max_fragment_shading_rate_invocation_count =
46715            max_fragment_shading_rate_invocation_count;
46716        self
46717    }
46718    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46719    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46720    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46721    pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
46722        self.inner
46723    }
46724}
46725#[repr(C)]
46726#[cfg_attr(feature = "debug", derive(Debug))]
46727#[derive(Copy, Clone)]
46728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html>"]
46729pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
46730    pub s_type: StructureType,
46731    pub p_next: *const c_void,
46732    pub shading_rate_type: FragmentShadingRateTypeNV,
46733    pub shading_rate: FragmentShadingRateNV,
46734    pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
46735}
46736impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV {
46737    fn default() -> Self {
46738        Self {
46739            s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV,
46740            p_next: ::std::ptr::null(),
46741            shading_rate_type: FragmentShadingRateTypeNV::default(),
46742            shading_rate: FragmentShadingRateNV::default(),
46743            combiner_ops: unsafe { ::std::mem::zeroed() },
46744        }
46745    }
46746}
46747impl PipelineFragmentShadingRateEnumStateCreateInfoNV {
46748    pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46749        PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder {
46750            inner: Self::default(),
46751            marker: ::std::marker::PhantomData,
46752        }
46753    }
46754}
46755#[repr(transparent)]
46756pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46757    inner: PipelineFragmentShadingRateEnumStateCreateInfoNV,
46758    marker: ::std::marker::PhantomData<&'a ()>,
46759}
46760unsafe impl ExtendsGraphicsPipelineCreateInfo
46761    for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_>
46762{
46763}
46764unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {}
46765impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46766    type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV;
46767    fn deref(&self) -> &Self::Target {
46768        &self.inner
46769    }
46770}
46771impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46772    fn deref_mut(&mut self) -> &mut Self::Target {
46773        &mut self.inner
46774    }
46775}
46776impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
46777    pub fn shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self {
46778        self.inner.shading_rate_type = shading_rate_type;
46779        self
46780    }
46781    pub fn shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self {
46782        self.inner.shading_rate = shading_rate;
46783        self
46784    }
46785    pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
46786        self.inner.combiner_ops = combiner_ops;
46787        self
46788    }
46789    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46790    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46791    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46792    pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV {
46793        self.inner
46794    }
46795}
46796#[repr(C)]
46797#[cfg_attr(feature = "debug", derive(Debug))]
46798#[derive(Copy, Clone)]
46799#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildSizesInfoKHR.html>"]
46800pub struct AccelerationStructureBuildSizesInfoKHR {
46801    pub s_type: StructureType,
46802    pub p_next: *const c_void,
46803    pub acceleration_structure_size: DeviceSize,
46804    pub update_scratch_size: DeviceSize,
46805    pub build_scratch_size: DeviceSize,
46806}
46807impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR {
46808    fn default() -> Self {
46809        Self {
46810            s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
46811            p_next: ::std::ptr::null(),
46812            acceleration_structure_size: DeviceSize::default(),
46813            update_scratch_size: DeviceSize::default(),
46814            build_scratch_size: DeviceSize::default(),
46815        }
46816    }
46817}
46818impl AccelerationStructureBuildSizesInfoKHR {
46819    pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46820        AccelerationStructureBuildSizesInfoKHRBuilder {
46821            inner: Self::default(),
46822            marker: ::std::marker::PhantomData,
46823        }
46824    }
46825}
46826#[repr(transparent)]
46827pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46828    inner: AccelerationStructureBuildSizesInfoKHR,
46829    marker: ::std::marker::PhantomData<&'a ()>,
46830}
46831impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46832    type Target = AccelerationStructureBuildSizesInfoKHR;
46833    fn deref(&self) -> &Self::Target {
46834        &self.inner
46835    }
46836}
46837impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46838    fn deref_mut(&mut self) -> &mut Self::Target {
46839        &mut self.inner
46840    }
46841}
46842impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
46843    pub fn acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self {
46844        self.inner.acceleration_structure_size = acceleration_structure_size;
46845        self
46846    }
46847    pub fn update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self {
46848        self.inner.update_scratch_size = update_scratch_size;
46849        self
46850    }
46851    pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self {
46852        self.inner.build_scratch_size = build_scratch_size;
46853        self
46854    }
46855    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46856    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46857    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46858    pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR {
46859        self.inner
46860    }
46861}
46862#[repr(C)]
46863#[cfg_attr(feature = "debug", derive(Debug))]
46864#[derive(Copy, Clone)]
46865#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html>"]
46866pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46867    pub s_type: StructureType,
46868    pub p_next: *mut c_void,
46869    pub mutable_descriptor_type: Bool32,
46870}
46871impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46872    fn default() -> Self {
46873        Self {
46874            s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
46875            p_next: ::std::ptr::null_mut(),
46876            mutable_descriptor_type: Bool32::default(),
46877        }
46878    }
46879}
46880impl PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46881    pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46882        PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder {
46883            inner: Self::default(),
46884            marker: ::std::marker::PhantomData,
46885        }
46886    }
46887}
46888#[repr(transparent)]
46889pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46890    inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE,
46891    marker: ::std::marker::PhantomData<&'a ()>,
46892}
46893unsafe impl ExtendsPhysicalDeviceFeatures2
46894    for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
46895{
46896}
46897unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
46898unsafe impl ExtendsDeviceCreateInfo
46899    for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
46900{
46901}
46902unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
46903impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46904    type Target = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
46905    fn deref(&self) -> &Self::Target {
46906        &self.inner
46907    }
46908}
46909impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46910    fn deref_mut(&mut self) -> &mut Self::Target {
46911        &mut self.inner
46912    }
46913}
46914impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
46915    pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self {
46916        self.inner.mutable_descriptor_type = mutable_descriptor_type.into();
46917        self
46918    }
46919    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46920    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46921    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46922    pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
46923        self.inner
46924    }
46925}
46926#[repr(C)]
46927#[cfg_attr(feature = "debug", derive(Debug))]
46928#[derive(Copy, Clone)]
46929#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeListVALVE.html>"]
46930pub struct MutableDescriptorTypeListVALVE {
46931    pub descriptor_type_count: u32,
46932    pub p_descriptor_types: *const DescriptorType,
46933}
46934impl ::std::default::Default for MutableDescriptorTypeListVALVE {
46935    fn default() -> Self {
46936        Self {
46937            descriptor_type_count: u32::default(),
46938            p_descriptor_types: ::std::ptr::null(),
46939        }
46940    }
46941}
46942impl MutableDescriptorTypeListVALVE {
46943    pub fn builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a> {
46944        MutableDescriptorTypeListVALVEBuilder {
46945            inner: Self::default(),
46946            marker: ::std::marker::PhantomData,
46947        }
46948    }
46949}
46950#[repr(transparent)]
46951pub struct MutableDescriptorTypeListVALVEBuilder<'a> {
46952    inner: MutableDescriptorTypeListVALVE,
46953    marker: ::std::marker::PhantomData<&'a ()>,
46954}
46955impl<'a> ::std::ops::Deref for MutableDescriptorTypeListVALVEBuilder<'a> {
46956    type Target = MutableDescriptorTypeListVALVE;
46957    fn deref(&self) -> &Self::Target {
46958        &self.inner
46959    }
46960}
46961impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListVALVEBuilder<'a> {
46962    fn deref_mut(&mut self) -> &mut Self::Target {
46963        &mut self.inner
46964    }
46965}
46966impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> {
46967    pub fn descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self {
46968        self.inner.descriptor_type_count = descriptor_types.len() as _;
46969        self.inner.p_descriptor_types = descriptor_types.as_ptr();
46970        self
46971    }
46972    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46973    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46974    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
46975    pub fn build(self) -> MutableDescriptorTypeListVALVE {
46976        self.inner
46977    }
46978}
46979#[repr(C)]
46980#[cfg_attr(feature = "debug", derive(Debug))]
46981#[derive(Copy, Clone)]
46982#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeCreateInfoVALVE.html>"]
46983pub struct MutableDescriptorTypeCreateInfoVALVE {
46984    pub s_type: StructureType,
46985    pub p_next: *const c_void,
46986    pub mutable_descriptor_type_list_count: u32,
46987    pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE,
46988}
46989impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE {
46990    fn default() -> Self {
46991        Self {
46992            s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
46993            p_next: ::std::ptr::null(),
46994            mutable_descriptor_type_list_count: u32::default(),
46995            p_mutable_descriptor_type_lists: ::std::ptr::null(),
46996        }
46997    }
46998}
46999impl MutableDescriptorTypeCreateInfoVALVE {
47000    pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47001        MutableDescriptorTypeCreateInfoVALVEBuilder {
47002            inner: Self::default(),
47003            marker: ::std::marker::PhantomData,
47004        }
47005    }
47006}
47007#[repr(transparent)]
47008pub struct MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47009    inner: MutableDescriptorTypeCreateInfoVALVE,
47010    marker: ::std::marker::PhantomData<&'a ()>,
47011}
47012unsafe impl ExtendsDescriptorSetLayoutCreateInfo
47013    for MutableDescriptorTypeCreateInfoVALVEBuilder<'_>
47014{
47015}
47016unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
47017unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> {}
47018unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
47019impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47020    type Target = MutableDescriptorTypeCreateInfoVALVE;
47021    fn deref(&self) -> &Self::Target {
47022        &self.inner
47023    }
47024}
47025impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47026    fn deref_mut(&mut self) -> &mut Self::Target {
47027        &mut self.inner
47028    }
47029}
47030impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
47031    pub fn mutable_descriptor_type_lists(
47032        mut self,
47033        mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE],
47034    ) -> Self {
47035        self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _;
47036        self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr();
47037        self
47038    }
47039    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47040    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47041    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47042    pub fn build(self) -> MutableDescriptorTypeCreateInfoVALVE {
47043        self.inner
47044    }
47045}
47046#[repr(C)]
47047#[cfg_attr(feature = "debug", derive(Debug))]
47048#[derive(Copy, Clone)]
47049#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html>"]
47050pub struct PhysicalDeviceDepthClipControlFeaturesEXT {
47051    pub s_type: StructureType,
47052    pub p_next: *mut c_void,
47053    pub depth_clip_control: Bool32,
47054}
47055impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT {
47056    fn default() -> Self {
47057        Self {
47058            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT,
47059            p_next: ::std::ptr::null_mut(),
47060            depth_clip_control: Bool32::default(),
47061        }
47062    }
47063}
47064impl PhysicalDeviceDepthClipControlFeaturesEXT {
47065    pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47066        PhysicalDeviceDepthClipControlFeaturesEXTBuilder {
47067            inner: Self::default(),
47068            marker: ::std::marker::PhantomData,
47069        }
47070    }
47071}
47072#[repr(transparent)]
47073pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47074    inner: PhysicalDeviceDepthClipControlFeaturesEXT,
47075    marker: ::std::marker::PhantomData<&'a ()>,
47076}
47077unsafe impl ExtendsPhysicalDeviceFeatures2
47078    for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_>
47079{
47080}
47081unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {}
47082unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {}
47083unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {}
47084impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47085    type Target = PhysicalDeviceDepthClipControlFeaturesEXT;
47086    fn deref(&self) -> &Self::Target {
47087        &self.inner
47088    }
47089}
47090impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47091    fn deref_mut(&mut self) -> &mut Self::Target {
47092        &mut self.inner
47093    }
47094}
47095impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
47096    pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self {
47097        self.inner.depth_clip_control = depth_clip_control.into();
47098        self
47099    }
47100    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47101    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47102    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47103    pub fn build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT {
47104        self.inner
47105    }
47106}
47107#[repr(C)]
47108#[cfg_attr(feature = "debug", derive(Debug))]
47109#[derive(Copy, Clone)]
47110#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html>"]
47111pub struct PipelineViewportDepthClipControlCreateInfoEXT {
47112    pub s_type: StructureType,
47113    pub p_next: *const c_void,
47114    pub negative_one_to_one: Bool32,
47115}
47116impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT {
47117    fn default() -> Self {
47118        Self {
47119            s_type: StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT,
47120            p_next: ::std::ptr::null(),
47121            negative_one_to_one: Bool32::default(),
47122        }
47123    }
47124}
47125impl PipelineViewportDepthClipControlCreateInfoEXT {
47126    pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47127        PipelineViewportDepthClipControlCreateInfoEXTBuilder {
47128            inner: Self::default(),
47129            marker: ::std::marker::PhantomData,
47130        }
47131    }
47132}
47133#[repr(transparent)]
47134pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47135    inner: PipelineViewportDepthClipControlCreateInfoEXT,
47136    marker: ::std::marker::PhantomData<&'a ()>,
47137}
47138unsafe impl ExtendsPipelineViewportStateCreateInfo
47139    for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_>
47140{
47141}
47142unsafe impl ExtendsPipelineViewportStateCreateInfo
47143    for PipelineViewportDepthClipControlCreateInfoEXT
47144{
47145}
47146impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47147    type Target = PipelineViewportDepthClipControlCreateInfoEXT;
47148    fn deref(&self) -> &Self::Target {
47149        &self.inner
47150    }
47151}
47152impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47153    fn deref_mut(&mut self) -> &mut Self::Target {
47154        &mut self.inner
47155    }
47156}
47157impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
47158    pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self {
47159        self.inner.negative_one_to_one = negative_one_to_one.into();
47160        self
47161    }
47162    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47163    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47164    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47165    pub fn build(self) -> PipelineViewportDepthClipControlCreateInfoEXT {
47166        self.inner
47167    }
47168}
47169#[repr(C)]
47170#[cfg_attr(feature = "debug", derive(Debug))]
47171#[derive(Copy, Clone)]
47172#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html>"]
47173pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47174    pub s_type: StructureType,
47175    pub p_next: *mut c_void,
47176    pub vertex_input_dynamic_state: Bool32,
47177}
47178impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47179    fn default() -> Self {
47180        Self {
47181            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
47182            p_next: ::std::ptr::null_mut(),
47183            vertex_input_dynamic_state: Bool32::default(),
47184        }
47185    }
47186}
47187impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47188    pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47189        PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder {
47190            inner: Self::default(),
47191            marker: ::std::marker::PhantomData,
47192        }
47193    }
47194}
47195#[repr(transparent)]
47196pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47197    inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT,
47198    marker: ::std::marker::PhantomData<&'a ()>,
47199}
47200unsafe impl ExtendsPhysicalDeviceFeatures2
47201    for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_>
47202{
47203}
47204unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {}
47205unsafe impl ExtendsDeviceCreateInfo
47206    for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_>
47207{
47208}
47209unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {}
47210impl<'a> ::std::ops::Deref for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47211    type Target = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
47212    fn deref(&self) -> &Self::Target {
47213        &self.inner
47214    }
47215}
47216impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47217    fn deref_mut(&mut self) -> &mut Self::Target {
47218        &mut self.inner
47219    }
47220}
47221impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
47222    pub fn vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self {
47223        self.inner.vertex_input_dynamic_state = vertex_input_dynamic_state.into();
47224        self
47225    }
47226    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47227    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47228    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47229    pub fn build(self) -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
47230        self.inner
47231    }
47232}
47233#[repr(C)]
47234#[cfg_attr(feature = "debug", derive(Debug))]
47235#[derive(Copy, Clone)]
47236#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html>"]
47237pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47238    pub s_type: StructureType,
47239    pub p_next: *mut c_void,
47240    pub external_memory_rdma: Bool32,
47241}
47242impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47243    fn default() -> Self {
47244        Self {
47245            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV,
47246            p_next: ::std::ptr::null_mut(),
47247            external_memory_rdma: Bool32::default(),
47248        }
47249    }
47250}
47251impl PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47252    pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47253        PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder {
47254            inner: Self::default(),
47255            marker: ::std::marker::PhantomData,
47256        }
47257    }
47258}
47259#[repr(transparent)]
47260pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47261    inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV,
47262    marker: ::std::marker::PhantomData<&'a ()>,
47263}
47264unsafe impl ExtendsPhysicalDeviceFeatures2
47265    for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_>
47266{
47267}
47268unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV {}
47269unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> {}
47270unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV {}
47271impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47272    type Target = PhysicalDeviceExternalMemoryRDMAFeaturesNV;
47273    fn deref(&self) -> &Self::Target {
47274        &self.inner
47275    }
47276}
47277impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47278    fn deref_mut(&mut self) -> &mut Self::Target {
47279        &mut self.inner
47280    }
47281}
47282impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
47283    pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self {
47284        self.inner.external_memory_rdma = external_memory_rdma.into();
47285        self
47286    }
47287    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47288    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47289    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47290    pub fn build(self) -> PhysicalDeviceExternalMemoryRDMAFeaturesNV {
47291        self.inner
47292    }
47293}
47294#[repr(C)]
47295#[cfg_attr(feature = "debug", derive(Debug))]
47296#[derive(Copy, Clone)]
47297#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription2EXT.html>"]
47298pub struct VertexInputBindingDescription2EXT {
47299    pub s_type: StructureType,
47300    pub p_next: *mut c_void,
47301    pub binding: u32,
47302    pub stride: u32,
47303    pub input_rate: VertexInputRate,
47304    pub divisor: u32,
47305}
47306impl ::std::default::Default for VertexInputBindingDescription2EXT {
47307    fn default() -> Self {
47308        Self {
47309            s_type: StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT,
47310            p_next: ::std::ptr::null_mut(),
47311            binding: u32::default(),
47312            stride: u32::default(),
47313            input_rate: VertexInputRate::default(),
47314            divisor: u32::default(),
47315        }
47316    }
47317}
47318impl VertexInputBindingDescription2EXT {
47319    pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> {
47320        VertexInputBindingDescription2EXTBuilder {
47321            inner: Self::default(),
47322            marker: ::std::marker::PhantomData,
47323        }
47324    }
47325}
47326#[repr(transparent)]
47327pub struct VertexInputBindingDescription2EXTBuilder<'a> {
47328    inner: VertexInputBindingDescription2EXT,
47329    marker: ::std::marker::PhantomData<&'a ()>,
47330}
47331impl<'a> ::std::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> {
47332    type Target = VertexInputBindingDescription2EXT;
47333    fn deref(&self) -> &Self::Target {
47334        &self.inner
47335    }
47336}
47337impl<'a> ::std::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> {
47338    fn deref_mut(&mut self) -> &mut Self::Target {
47339        &mut self.inner
47340    }
47341}
47342impl<'a> VertexInputBindingDescription2EXTBuilder<'a> {
47343    pub fn binding(mut self, binding: u32) -> Self {
47344        self.inner.binding = binding;
47345        self
47346    }
47347    pub fn stride(mut self, stride: u32) -> Self {
47348        self.inner.stride = stride;
47349        self
47350    }
47351    pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
47352        self.inner.input_rate = input_rate;
47353        self
47354    }
47355    pub fn divisor(mut self, divisor: u32) -> Self {
47356        self.inner.divisor = divisor;
47357        self
47358    }
47359    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47360    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47361    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47362    pub fn build(self) -> VertexInputBindingDescription2EXT {
47363        self.inner
47364    }
47365}
47366#[repr(C)]
47367#[cfg_attr(feature = "debug", derive(Debug))]
47368#[derive(Copy, Clone)]
47369#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription2EXT.html>"]
47370pub struct VertexInputAttributeDescription2EXT {
47371    pub s_type: StructureType,
47372    pub p_next: *mut c_void,
47373    pub location: u32,
47374    pub binding: u32,
47375    pub format: Format,
47376    pub offset: u32,
47377}
47378impl ::std::default::Default for VertexInputAttributeDescription2EXT {
47379    fn default() -> Self {
47380        Self {
47381            s_type: StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
47382            p_next: ::std::ptr::null_mut(),
47383            location: u32::default(),
47384            binding: u32::default(),
47385            format: Format::default(),
47386            offset: u32::default(),
47387        }
47388    }
47389}
47390impl VertexInputAttributeDescription2EXT {
47391    pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> {
47392        VertexInputAttributeDescription2EXTBuilder {
47393            inner: Self::default(),
47394            marker: ::std::marker::PhantomData,
47395        }
47396    }
47397}
47398#[repr(transparent)]
47399pub struct VertexInputAttributeDescription2EXTBuilder<'a> {
47400    inner: VertexInputAttributeDescription2EXT,
47401    marker: ::std::marker::PhantomData<&'a ()>,
47402}
47403impl<'a> ::std::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> {
47404    type Target = VertexInputAttributeDescription2EXT;
47405    fn deref(&self) -> &Self::Target {
47406        &self.inner
47407    }
47408}
47409impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a> {
47410    fn deref_mut(&mut self) -> &mut Self::Target {
47411        &mut self.inner
47412    }
47413}
47414impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> {
47415    pub fn location(mut self, location: u32) -> Self {
47416        self.inner.location = location;
47417        self
47418    }
47419    pub fn binding(mut self, binding: u32) -> Self {
47420        self.inner.binding = binding;
47421        self
47422    }
47423    pub fn format(mut self, format: Format) -> Self {
47424        self.inner.format = format;
47425        self
47426    }
47427    pub fn offset(mut self, offset: u32) -> Self {
47428        self.inner.offset = offset;
47429        self
47430    }
47431    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47432    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47433    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47434    pub fn build(self) -> VertexInputAttributeDescription2EXT {
47435        self.inner
47436    }
47437}
47438#[repr(C)]
47439#[cfg_attr(feature = "debug", derive(Debug))]
47440#[derive(Copy, Clone)]
47441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html>"]
47442pub struct PhysicalDeviceColorWriteEnableFeaturesEXT {
47443    pub s_type: StructureType,
47444    pub p_next: *mut c_void,
47445    pub color_write_enable: Bool32,
47446}
47447impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT {
47448    fn default() -> Self {
47449        Self {
47450            s_type: StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT,
47451            p_next: ::std::ptr::null_mut(),
47452            color_write_enable: Bool32::default(),
47453        }
47454    }
47455}
47456impl PhysicalDeviceColorWriteEnableFeaturesEXT {
47457    pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47458        PhysicalDeviceColorWriteEnableFeaturesEXTBuilder {
47459            inner: Self::default(),
47460            marker: ::std::marker::PhantomData,
47461        }
47462    }
47463}
47464#[repr(transparent)]
47465pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47466    inner: PhysicalDeviceColorWriteEnableFeaturesEXT,
47467    marker: ::std::marker::PhantomData<&'a ()>,
47468}
47469unsafe impl ExtendsPhysicalDeviceFeatures2
47470    for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_>
47471{
47472}
47473unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT {}
47474unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> {}
47475unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT {}
47476impl<'a> ::std::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47477    type Target = PhysicalDeviceColorWriteEnableFeaturesEXT;
47478    fn deref(&self) -> &Self::Target {
47479        &self.inner
47480    }
47481}
47482impl<'a> ::std::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47483    fn deref_mut(&mut self) -> &mut Self::Target {
47484        &mut self.inner
47485    }
47486}
47487impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
47488    pub fn color_write_enable(mut self, color_write_enable: bool) -> Self {
47489        self.inner.color_write_enable = color_write_enable.into();
47490        self
47491    }
47492    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47493    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47494    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47495    pub fn build(self) -> PhysicalDeviceColorWriteEnableFeaturesEXT {
47496        self.inner
47497    }
47498}
47499#[repr(C)]
47500#[cfg_attr(feature = "debug", derive(Debug))]
47501#[derive(Copy, Clone)]
47502#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorWriteCreateInfoEXT.html>"]
47503pub struct PipelineColorWriteCreateInfoEXT {
47504    pub s_type: StructureType,
47505    pub p_next: *const c_void,
47506    pub attachment_count: u32,
47507    pub p_color_write_enables: *const Bool32,
47508}
47509impl ::std::default::Default for PipelineColorWriteCreateInfoEXT {
47510    fn default() -> Self {
47511        Self {
47512            s_type: StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT,
47513            p_next: ::std::ptr::null(),
47514            attachment_count: u32::default(),
47515            p_color_write_enables: ::std::ptr::null(),
47516        }
47517    }
47518}
47519impl PipelineColorWriteCreateInfoEXT {
47520    pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> {
47521        PipelineColorWriteCreateInfoEXTBuilder {
47522            inner: Self::default(),
47523            marker: ::std::marker::PhantomData,
47524        }
47525    }
47526}
47527#[repr(transparent)]
47528pub struct PipelineColorWriteCreateInfoEXTBuilder<'a> {
47529    inner: PipelineColorWriteCreateInfoEXT,
47530    marker: ::std::marker::PhantomData<&'a ()>,
47531}
47532unsafe impl ExtendsPipelineColorBlendStateCreateInfo
47533    for PipelineColorWriteCreateInfoEXTBuilder<'_>
47534{
47535}
47536unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT {}
47537impl<'a> ::std::ops::Deref for PipelineColorWriteCreateInfoEXTBuilder<'a> {
47538    type Target = PipelineColorWriteCreateInfoEXT;
47539    fn deref(&self) -> &Self::Target {
47540        &self.inner
47541    }
47542}
47543impl<'a> ::std::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> {
47544    fn deref_mut(&mut self) -> &mut Self::Target {
47545        &mut self.inner
47546    }
47547}
47548impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> {
47549    pub fn color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self {
47550        self.inner.attachment_count = color_write_enables.len() as _;
47551        self.inner.p_color_write_enables = color_write_enables.as_ptr();
47552        self
47553    }
47554    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47555    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47556    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47557    pub fn build(self) -> PipelineColorWriteCreateInfoEXT {
47558        self.inner
47559    }
47560}
47561#[repr(C)]
47562#[cfg_attr(feature = "debug", derive(Debug))]
47563#[derive(Copy, Clone)]
47564#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier2.html>"]
47565pub struct MemoryBarrier2 {
47566    pub s_type: StructureType,
47567    pub p_next: *const c_void,
47568    pub src_stage_mask: PipelineStageFlags2,
47569    pub src_access_mask: AccessFlags2,
47570    pub dst_stage_mask: PipelineStageFlags2,
47571    pub dst_access_mask: AccessFlags2,
47572}
47573impl ::std::default::Default for MemoryBarrier2 {
47574    fn default() -> Self {
47575        Self {
47576            s_type: StructureType::MEMORY_BARRIER_2,
47577            p_next: ::std::ptr::null(),
47578            src_stage_mask: PipelineStageFlags2::default(),
47579            src_access_mask: AccessFlags2::default(),
47580            dst_stage_mask: PipelineStageFlags2::default(),
47581            dst_access_mask: AccessFlags2::default(),
47582        }
47583    }
47584}
47585impl MemoryBarrier2 {
47586    pub fn builder<'a>() -> MemoryBarrier2Builder<'a> {
47587        MemoryBarrier2Builder {
47588            inner: Self::default(),
47589            marker: ::std::marker::PhantomData,
47590        }
47591    }
47592}
47593#[repr(transparent)]
47594pub struct MemoryBarrier2Builder<'a> {
47595    inner: MemoryBarrier2,
47596    marker: ::std::marker::PhantomData<&'a ()>,
47597}
47598unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2Builder<'_> {}
47599unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2 {}
47600impl<'a> ::std::ops::Deref for MemoryBarrier2Builder<'a> {
47601    type Target = MemoryBarrier2;
47602    fn deref(&self) -> &Self::Target {
47603        &self.inner
47604    }
47605}
47606impl<'a> ::std::ops::DerefMut for MemoryBarrier2Builder<'a> {
47607    fn deref_mut(&mut self) -> &mut Self::Target {
47608        &mut self.inner
47609    }
47610}
47611impl<'a> MemoryBarrier2Builder<'a> {
47612    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
47613        self.inner.src_stage_mask = src_stage_mask;
47614        self
47615    }
47616    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
47617        self.inner.src_access_mask = src_access_mask;
47618        self
47619    }
47620    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
47621        self.inner.dst_stage_mask = dst_stage_mask;
47622        self
47623    }
47624    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
47625        self.inner.dst_access_mask = dst_access_mask;
47626        self
47627    }
47628    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47629    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47630    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47631    pub fn build(self) -> MemoryBarrier2 {
47632        self.inner
47633    }
47634}
47635#[repr(C)]
47636#[cfg_attr(feature = "debug", derive(Debug))]
47637#[derive(Copy, Clone)]
47638#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier2.html>"]
47639pub struct ImageMemoryBarrier2 {
47640    pub s_type: StructureType,
47641    pub p_next: *const c_void,
47642    pub src_stage_mask: PipelineStageFlags2,
47643    pub src_access_mask: AccessFlags2,
47644    pub dst_stage_mask: PipelineStageFlags2,
47645    pub dst_access_mask: AccessFlags2,
47646    pub old_layout: ImageLayout,
47647    pub new_layout: ImageLayout,
47648    pub src_queue_family_index: u32,
47649    pub dst_queue_family_index: u32,
47650    pub image: Image,
47651    pub subresource_range: ImageSubresourceRange,
47652}
47653impl ::std::default::Default for ImageMemoryBarrier2 {
47654    fn default() -> Self {
47655        Self {
47656            s_type: StructureType::IMAGE_MEMORY_BARRIER_2,
47657            p_next: ::std::ptr::null(),
47658            src_stage_mask: PipelineStageFlags2::default(),
47659            src_access_mask: AccessFlags2::default(),
47660            dst_stage_mask: PipelineStageFlags2::default(),
47661            dst_access_mask: AccessFlags2::default(),
47662            old_layout: ImageLayout::default(),
47663            new_layout: ImageLayout::default(),
47664            src_queue_family_index: u32::default(),
47665            dst_queue_family_index: u32::default(),
47666            image: Image::default(),
47667            subresource_range: ImageSubresourceRange::default(),
47668        }
47669    }
47670}
47671impl ImageMemoryBarrier2 {
47672    pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> {
47673        ImageMemoryBarrier2Builder {
47674            inner: Self::default(),
47675            marker: ::std::marker::PhantomData,
47676        }
47677    }
47678}
47679#[repr(transparent)]
47680pub struct ImageMemoryBarrier2Builder<'a> {
47681    inner: ImageMemoryBarrier2,
47682    marker: ::std::marker::PhantomData<&'a ()>,
47683}
47684pub unsafe trait ExtendsImageMemoryBarrier2 {}
47685impl<'a> ::std::ops::Deref for ImageMemoryBarrier2Builder<'a> {
47686    type Target = ImageMemoryBarrier2;
47687    fn deref(&self) -> &Self::Target {
47688        &self.inner
47689    }
47690}
47691impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2Builder<'a> {
47692    fn deref_mut(&mut self) -> &mut Self::Target {
47693        &mut self.inner
47694    }
47695}
47696impl<'a> ImageMemoryBarrier2Builder<'a> {
47697    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
47698        self.inner.src_stage_mask = src_stage_mask;
47699        self
47700    }
47701    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
47702        self.inner.src_access_mask = src_access_mask;
47703        self
47704    }
47705    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
47706        self.inner.dst_stage_mask = dst_stage_mask;
47707        self
47708    }
47709    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
47710        self.inner.dst_access_mask = dst_access_mask;
47711        self
47712    }
47713    pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
47714        self.inner.old_layout = old_layout;
47715        self
47716    }
47717    pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
47718        self.inner.new_layout = new_layout;
47719        self
47720    }
47721    pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
47722        self.inner.src_queue_family_index = src_queue_family_index;
47723        self
47724    }
47725    pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
47726        self.inner.dst_queue_family_index = dst_queue_family_index;
47727        self
47728    }
47729    pub fn image(mut self, image: Image) -> Self {
47730        self.inner.image = image;
47731        self
47732    }
47733    pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
47734        self.inner.subresource_range = subresource_range;
47735        self
47736    }
47737    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47738    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47739    #[doc = r" valid extension structs can be pushed into the chain."]
47740    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47741    #[doc = r" chain will look like `A -> D -> B -> C`."]
47742    pub fn push_next<T: ExtendsImageMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
47743        unsafe {
47744            let next_ptr = <*const T>::cast(next);
47745            let last_next = ptr_chain_iter(next).last().unwrap();
47746            (*last_next).p_next = self.inner.p_next as _;
47747            self.inner.p_next = next_ptr;
47748        }
47749        self
47750    }
47751    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47752    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47753    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47754    pub fn build(self) -> ImageMemoryBarrier2 {
47755        self.inner
47756    }
47757}
47758#[repr(C)]
47759#[cfg_attr(feature = "debug", derive(Debug))]
47760#[derive(Copy, Clone)]
47761#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier2.html>"]
47762pub struct BufferMemoryBarrier2 {
47763    pub s_type: StructureType,
47764    pub p_next: *const c_void,
47765    pub src_stage_mask: PipelineStageFlags2,
47766    pub src_access_mask: AccessFlags2,
47767    pub dst_stage_mask: PipelineStageFlags2,
47768    pub dst_access_mask: AccessFlags2,
47769    pub src_queue_family_index: u32,
47770    pub dst_queue_family_index: u32,
47771    pub buffer: Buffer,
47772    pub offset: DeviceSize,
47773    pub size: DeviceSize,
47774}
47775impl ::std::default::Default for BufferMemoryBarrier2 {
47776    fn default() -> Self {
47777        Self {
47778            s_type: StructureType::BUFFER_MEMORY_BARRIER_2,
47779            p_next: ::std::ptr::null(),
47780            src_stage_mask: PipelineStageFlags2::default(),
47781            src_access_mask: AccessFlags2::default(),
47782            dst_stage_mask: PipelineStageFlags2::default(),
47783            dst_access_mask: AccessFlags2::default(),
47784            src_queue_family_index: u32::default(),
47785            dst_queue_family_index: u32::default(),
47786            buffer: Buffer::default(),
47787            offset: DeviceSize::default(),
47788            size: DeviceSize::default(),
47789        }
47790    }
47791}
47792impl BufferMemoryBarrier2 {
47793    pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> {
47794        BufferMemoryBarrier2Builder {
47795            inner: Self::default(),
47796            marker: ::std::marker::PhantomData,
47797        }
47798    }
47799}
47800#[repr(transparent)]
47801pub struct BufferMemoryBarrier2Builder<'a> {
47802    inner: BufferMemoryBarrier2,
47803    marker: ::std::marker::PhantomData<&'a ()>,
47804}
47805impl<'a> ::std::ops::Deref for BufferMemoryBarrier2Builder<'a> {
47806    type Target = BufferMemoryBarrier2;
47807    fn deref(&self) -> &Self::Target {
47808        &self.inner
47809    }
47810}
47811impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2Builder<'a> {
47812    fn deref_mut(&mut self) -> &mut Self::Target {
47813        &mut self.inner
47814    }
47815}
47816impl<'a> BufferMemoryBarrier2Builder<'a> {
47817    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
47818        self.inner.src_stage_mask = src_stage_mask;
47819        self
47820    }
47821    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
47822        self.inner.src_access_mask = src_access_mask;
47823        self
47824    }
47825    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
47826        self.inner.dst_stage_mask = dst_stage_mask;
47827        self
47828    }
47829    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
47830        self.inner.dst_access_mask = dst_access_mask;
47831        self
47832    }
47833    pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
47834        self.inner.src_queue_family_index = src_queue_family_index;
47835        self
47836    }
47837    pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
47838        self.inner.dst_queue_family_index = dst_queue_family_index;
47839        self
47840    }
47841    pub fn buffer(mut self, buffer: Buffer) -> Self {
47842        self.inner.buffer = buffer;
47843        self
47844    }
47845    pub fn offset(mut self, offset: DeviceSize) -> Self {
47846        self.inner.offset = offset;
47847        self
47848    }
47849    pub fn size(mut self, size: DeviceSize) -> Self {
47850        self.inner.size = size;
47851        self
47852    }
47853    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47854    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47855    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47856    pub fn build(self) -> BufferMemoryBarrier2 {
47857        self.inner
47858    }
47859}
47860#[repr(C)]
47861#[cfg_attr(feature = "debug", derive(Debug))]
47862#[derive(Copy, Clone)]
47863#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyInfo.html>"]
47864pub struct DependencyInfo {
47865    pub s_type: StructureType,
47866    pub p_next: *const c_void,
47867    pub dependency_flags: DependencyFlags,
47868    pub memory_barrier_count: u32,
47869    pub p_memory_barriers: *const MemoryBarrier2,
47870    pub buffer_memory_barrier_count: u32,
47871    pub p_buffer_memory_barriers: *const BufferMemoryBarrier2,
47872    pub image_memory_barrier_count: u32,
47873    pub p_image_memory_barriers: *const ImageMemoryBarrier2,
47874}
47875impl ::std::default::Default for DependencyInfo {
47876    fn default() -> Self {
47877        Self {
47878            s_type: StructureType::DEPENDENCY_INFO,
47879            p_next: ::std::ptr::null(),
47880            dependency_flags: DependencyFlags::default(),
47881            memory_barrier_count: u32::default(),
47882            p_memory_barriers: ::std::ptr::null(),
47883            buffer_memory_barrier_count: u32::default(),
47884            p_buffer_memory_barriers: ::std::ptr::null(),
47885            image_memory_barrier_count: u32::default(),
47886            p_image_memory_barriers: ::std::ptr::null(),
47887        }
47888    }
47889}
47890impl DependencyInfo {
47891    pub fn builder<'a>() -> DependencyInfoBuilder<'a> {
47892        DependencyInfoBuilder {
47893            inner: Self::default(),
47894            marker: ::std::marker::PhantomData,
47895        }
47896    }
47897}
47898#[repr(transparent)]
47899pub struct DependencyInfoBuilder<'a> {
47900    inner: DependencyInfo,
47901    marker: ::std::marker::PhantomData<&'a ()>,
47902}
47903impl<'a> ::std::ops::Deref for DependencyInfoBuilder<'a> {
47904    type Target = DependencyInfo;
47905    fn deref(&self) -> &Self::Target {
47906        &self.inner
47907    }
47908}
47909impl<'a> ::std::ops::DerefMut for DependencyInfoBuilder<'a> {
47910    fn deref_mut(&mut self) -> &mut Self::Target {
47911        &mut self.inner
47912    }
47913}
47914impl<'a> DependencyInfoBuilder<'a> {
47915    pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
47916        self.inner.dependency_flags = dependency_flags;
47917        self
47918    }
47919    pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self {
47920        self.inner.memory_barrier_count = memory_barriers.len() as _;
47921        self.inner.p_memory_barriers = memory_barriers.as_ptr();
47922        self
47923    }
47924    pub fn buffer_memory_barriers(
47925        mut self,
47926        buffer_memory_barriers: &'a [BufferMemoryBarrier2],
47927    ) -> Self {
47928        self.inner.buffer_memory_barrier_count = buffer_memory_barriers.len() as _;
47929        self.inner.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr();
47930        self
47931    }
47932    pub fn image_memory_barriers(
47933        mut self,
47934        image_memory_barriers: &'a [ImageMemoryBarrier2],
47935    ) -> Self {
47936        self.inner.image_memory_barrier_count = image_memory_barriers.len() as _;
47937        self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr();
47938        self
47939    }
47940    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47941    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47942    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
47943    pub fn build(self) -> DependencyInfo {
47944        self.inner
47945    }
47946}
47947#[repr(C)]
47948#[cfg_attr(feature = "debug", derive(Debug))]
47949#[derive(Copy, Clone)]
47950#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSubmitInfo.html>"]
47951pub struct SemaphoreSubmitInfo {
47952    pub s_type: StructureType,
47953    pub p_next: *const c_void,
47954    pub semaphore: Semaphore,
47955    pub value: u64,
47956    pub stage_mask: PipelineStageFlags2,
47957    pub device_index: u32,
47958}
47959impl ::std::default::Default for SemaphoreSubmitInfo {
47960    fn default() -> Self {
47961        Self {
47962            s_type: StructureType::SEMAPHORE_SUBMIT_INFO,
47963            p_next: ::std::ptr::null(),
47964            semaphore: Semaphore::default(),
47965            value: u64::default(),
47966            stage_mask: PipelineStageFlags2::default(),
47967            device_index: u32::default(),
47968        }
47969    }
47970}
47971impl SemaphoreSubmitInfo {
47972    pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> {
47973        SemaphoreSubmitInfoBuilder {
47974            inner: Self::default(),
47975            marker: ::std::marker::PhantomData,
47976        }
47977    }
47978}
47979#[repr(transparent)]
47980pub struct SemaphoreSubmitInfoBuilder<'a> {
47981    inner: SemaphoreSubmitInfo,
47982    marker: ::std::marker::PhantomData<&'a ()>,
47983}
47984impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoBuilder<'a> {
47985    type Target = SemaphoreSubmitInfo;
47986    fn deref(&self) -> &Self::Target {
47987        &self.inner
47988    }
47989}
47990impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> {
47991    fn deref_mut(&mut self) -> &mut Self::Target {
47992        &mut self.inner
47993    }
47994}
47995impl<'a> SemaphoreSubmitInfoBuilder<'a> {
47996    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
47997        self.inner.semaphore = semaphore;
47998        self
47999    }
48000    pub fn value(mut self, value: u64) -> Self {
48001        self.inner.value = value;
48002        self
48003    }
48004    pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self {
48005        self.inner.stage_mask = stage_mask;
48006        self
48007    }
48008    pub fn device_index(mut self, device_index: u32) -> Self {
48009        self.inner.device_index = device_index;
48010        self
48011    }
48012    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48013    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48014    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48015    pub fn build(self) -> SemaphoreSubmitInfo {
48016        self.inner
48017    }
48018}
48019#[repr(C)]
48020#[cfg_attr(feature = "debug", derive(Debug))]
48021#[derive(Copy, Clone)]
48022#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferSubmitInfo.html>"]
48023pub struct CommandBufferSubmitInfo {
48024    pub s_type: StructureType,
48025    pub p_next: *const c_void,
48026    pub command_buffer: CommandBuffer,
48027    pub device_mask: u32,
48028}
48029impl ::std::default::Default for CommandBufferSubmitInfo {
48030    fn default() -> Self {
48031        Self {
48032            s_type: StructureType::COMMAND_BUFFER_SUBMIT_INFO,
48033            p_next: ::std::ptr::null(),
48034            command_buffer: CommandBuffer::default(),
48035            device_mask: u32::default(),
48036        }
48037    }
48038}
48039impl CommandBufferSubmitInfo {
48040    pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> {
48041        CommandBufferSubmitInfoBuilder {
48042            inner: Self::default(),
48043            marker: ::std::marker::PhantomData,
48044        }
48045    }
48046}
48047#[repr(transparent)]
48048pub struct CommandBufferSubmitInfoBuilder<'a> {
48049    inner: CommandBufferSubmitInfo,
48050    marker: ::std::marker::PhantomData<&'a ()>,
48051}
48052impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoBuilder<'a> {
48053    type Target = CommandBufferSubmitInfo;
48054    fn deref(&self) -> &Self::Target {
48055        &self.inner
48056    }
48057}
48058impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> {
48059    fn deref_mut(&mut self) -> &mut Self::Target {
48060        &mut self.inner
48061    }
48062}
48063impl<'a> CommandBufferSubmitInfoBuilder<'a> {
48064    pub fn command_buffer(mut self, command_buffer: CommandBuffer) -> Self {
48065        self.inner.command_buffer = command_buffer;
48066        self
48067    }
48068    pub fn device_mask(mut self, device_mask: u32) -> Self {
48069        self.inner.device_mask = device_mask;
48070        self
48071    }
48072    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48073    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48074    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48075    pub fn build(self) -> CommandBufferSubmitInfo {
48076        self.inner
48077    }
48078}
48079#[repr(C)]
48080#[cfg_attr(feature = "debug", derive(Debug))]
48081#[derive(Copy, Clone)]
48082#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo2.html>"]
48083pub struct SubmitInfo2 {
48084    pub s_type: StructureType,
48085    pub p_next: *const c_void,
48086    pub flags: SubmitFlags,
48087    pub wait_semaphore_info_count: u32,
48088    pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo,
48089    pub command_buffer_info_count: u32,
48090    pub p_command_buffer_infos: *const CommandBufferSubmitInfo,
48091    pub signal_semaphore_info_count: u32,
48092    pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo,
48093}
48094impl ::std::default::Default for SubmitInfo2 {
48095    fn default() -> Self {
48096        Self {
48097            s_type: StructureType::SUBMIT_INFO_2,
48098            p_next: ::std::ptr::null(),
48099            flags: SubmitFlags::default(),
48100            wait_semaphore_info_count: u32::default(),
48101            p_wait_semaphore_infos: ::std::ptr::null(),
48102            command_buffer_info_count: u32::default(),
48103            p_command_buffer_infos: ::std::ptr::null(),
48104            signal_semaphore_info_count: u32::default(),
48105            p_signal_semaphore_infos: ::std::ptr::null(),
48106        }
48107    }
48108}
48109impl SubmitInfo2 {
48110    pub fn builder<'a>() -> SubmitInfo2Builder<'a> {
48111        SubmitInfo2Builder {
48112            inner: Self::default(),
48113            marker: ::std::marker::PhantomData,
48114        }
48115    }
48116}
48117#[repr(transparent)]
48118pub struct SubmitInfo2Builder<'a> {
48119    inner: SubmitInfo2,
48120    marker: ::std::marker::PhantomData<&'a ()>,
48121}
48122pub unsafe trait ExtendsSubmitInfo2 {}
48123impl<'a> ::std::ops::Deref for SubmitInfo2Builder<'a> {
48124    type Target = SubmitInfo2;
48125    fn deref(&self) -> &Self::Target {
48126        &self.inner
48127    }
48128}
48129impl<'a> ::std::ops::DerefMut for SubmitInfo2Builder<'a> {
48130    fn deref_mut(&mut self) -> &mut Self::Target {
48131        &mut self.inner
48132    }
48133}
48134impl<'a> SubmitInfo2Builder<'a> {
48135    pub fn flags(mut self, flags: SubmitFlags) -> Self {
48136        self.inner.flags = flags;
48137        self
48138    }
48139    pub fn wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self {
48140        self.inner.wait_semaphore_info_count = wait_semaphore_infos.len() as _;
48141        self.inner.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr();
48142        self
48143    }
48144    pub fn command_buffer_infos(
48145        mut self,
48146        command_buffer_infos: &'a [CommandBufferSubmitInfo],
48147    ) -> Self {
48148        self.inner.command_buffer_info_count = command_buffer_infos.len() as _;
48149        self.inner.p_command_buffer_infos = command_buffer_infos.as_ptr();
48150        self
48151    }
48152    pub fn signal_semaphore_infos(
48153        mut self,
48154        signal_semaphore_infos: &'a [SemaphoreSubmitInfo],
48155    ) -> Self {
48156        self.inner.signal_semaphore_info_count = signal_semaphore_infos.len() as _;
48157        self.inner.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr();
48158        self
48159    }
48160    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48161    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48162    #[doc = r" valid extension structs can be pushed into the chain."]
48163    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48164    #[doc = r" chain will look like `A -> D -> B -> C`."]
48165    pub fn push_next<T: ExtendsSubmitInfo2>(mut self, next: &'a mut T) -> Self {
48166        unsafe {
48167            let next_ptr = <*const T>::cast(next);
48168            let last_next = ptr_chain_iter(next).last().unwrap();
48169            (*last_next).p_next = self.inner.p_next as _;
48170            self.inner.p_next = next_ptr;
48171        }
48172        self
48173    }
48174    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48175    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48176    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48177    pub fn build(self) -> SubmitInfo2 {
48178        self.inner
48179    }
48180}
48181#[repr(C)]
48182#[cfg_attr(feature = "debug", derive(Debug))]
48183#[derive(Copy, Clone)]
48184#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointProperties2NV.html>"]
48185pub struct QueueFamilyCheckpointProperties2NV {
48186    pub s_type: StructureType,
48187    pub p_next: *mut c_void,
48188    pub checkpoint_execution_stage_mask: PipelineStageFlags2,
48189}
48190impl ::std::default::Default for QueueFamilyCheckpointProperties2NV {
48191    fn default() -> Self {
48192        Self {
48193            s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
48194            p_next: ::std::ptr::null_mut(),
48195            checkpoint_execution_stage_mask: PipelineStageFlags2::default(),
48196        }
48197    }
48198}
48199impl QueueFamilyCheckpointProperties2NV {
48200    pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> {
48201        QueueFamilyCheckpointProperties2NVBuilder {
48202            inner: Self::default(),
48203            marker: ::std::marker::PhantomData,
48204        }
48205    }
48206}
48207#[repr(transparent)]
48208pub struct QueueFamilyCheckpointProperties2NVBuilder<'a> {
48209    inner: QueueFamilyCheckpointProperties2NV,
48210    marker: ::std::marker::PhantomData<&'a ()>,
48211}
48212unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NVBuilder<'_> {}
48213unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV {}
48214impl<'a> ::std::ops::Deref for QueueFamilyCheckpointProperties2NVBuilder<'a> {
48215    type Target = QueueFamilyCheckpointProperties2NV;
48216    fn deref(&self) -> &Self::Target {
48217        &self.inner
48218    }
48219}
48220impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a> {
48221    fn deref_mut(&mut self) -> &mut Self::Target {
48222        &mut self.inner
48223    }
48224}
48225impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> {
48226    pub fn checkpoint_execution_stage_mask(
48227        mut self,
48228        checkpoint_execution_stage_mask: PipelineStageFlags2,
48229    ) -> Self {
48230        self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
48231        self
48232    }
48233    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48234    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48235    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48236    pub fn build(self) -> QueueFamilyCheckpointProperties2NV {
48237        self.inner
48238    }
48239}
48240#[repr(C)]
48241#[cfg_attr(feature = "debug", derive(Debug))]
48242#[derive(Copy, Clone)]
48243#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointData2NV.html>"]
48244pub struct CheckpointData2NV {
48245    pub s_type: StructureType,
48246    pub p_next: *mut c_void,
48247    pub stage: PipelineStageFlags2,
48248    pub p_checkpoint_marker: *mut c_void,
48249}
48250impl ::std::default::Default for CheckpointData2NV {
48251    fn default() -> Self {
48252        Self {
48253            s_type: StructureType::CHECKPOINT_DATA_2_NV,
48254            p_next: ::std::ptr::null_mut(),
48255            stage: PipelineStageFlags2::default(),
48256            p_checkpoint_marker: ::std::ptr::null_mut(),
48257        }
48258    }
48259}
48260impl CheckpointData2NV {
48261    pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> {
48262        CheckpointData2NVBuilder {
48263            inner: Self::default(),
48264            marker: ::std::marker::PhantomData,
48265        }
48266    }
48267}
48268#[repr(transparent)]
48269pub struct CheckpointData2NVBuilder<'a> {
48270    inner: CheckpointData2NV,
48271    marker: ::std::marker::PhantomData<&'a ()>,
48272}
48273impl<'a> ::std::ops::Deref for CheckpointData2NVBuilder<'a> {
48274    type Target = CheckpointData2NV;
48275    fn deref(&self) -> &Self::Target {
48276        &self.inner
48277    }
48278}
48279impl<'a> ::std::ops::DerefMut for CheckpointData2NVBuilder<'a> {
48280    fn deref_mut(&mut self) -> &mut Self::Target {
48281        &mut self.inner
48282    }
48283}
48284impl<'a> CheckpointData2NVBuilder<'a> {
48285    pub fn stage(mut self, stage: PipelineStageFlags2) -> Self {
48286        self.inner.stage = stage;
48287        self
48288    }
48289    pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
48290        self.inner.p_checkpoint_marker = checkpoint_marker;
48291        self
48292    }
48293    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48294    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48295    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48296    pub fn build(self) -> CheckpointData2NV {
48297        self.inner
48298    }
48299}
48300#[repr(C)]
48301#[cfg_attr(feature = "debug", derive(Debug))]
48302#[derive(Copy, Clone)]
48303#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSynchronization2Features.html>"]
48304pub struct PhysicalDeviceSynchronization2Features {
48305    pub s_type: StructureType,
48306    pub p_next: *mut c_void,
48307    pub synchronization2: Bool32,
48308}
48309impl ::std::default::Default for PhysicalDeviceSynchronization2Features {
48310    fn default() -> Self {
48311        Self {
48312            s_type: StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES,
48313            p_next: ::std::ptr::null_mut(),
48314            synchronization2: Bool32::default(),
48315        }
48316    }
48317}
48318impl PhysicalDeviceSynchronization2Features {
48319    pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48320        PhysicalDeviceSynchronization2FeaturesBuilder {
48321            inner: Self::default(),
48322            marker: ::std::marker::PhantomData,
48323        }
48324    }
48325}
48326#[repr(transparent)]
48327pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48328    inner: PhysicalDeviceSynchronization2Features,
48329    marker: ::std::marker::PhantomData<&'a ()>,
48330}
48331unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
48332unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features {}
48333unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
48334unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features {}
48335impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48336    type Target = PhysicalDeviceSynchronization2Features;
48337    fn deref(&self) -> &Self::Target {
48338        &self.inner
48339    }
48340}
48341impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48342    fn deref_mut(&mut self) -> &mut Self::Target {
48343        &mut self.inner
48344    }
48345}
48346impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
48347    pub fn synchronization2(mut self, synchronization2: bool) -> Self {
48348        self.inner.synchronization2 = synchronization2.into();
48349        self
48350    }
48351    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48352    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48353    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48354    pub fn build(self) -> PhysicalDeviceSynchronization2Features {
48355        self.inner
48356    }
48357}
48358#[repr(C)]
48359#[cfg_attr(feature = "debug", derive(Debug))]
48360#[derive(Copy, Clone)]
48361#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoQueueFamilyProperties2KHR.html>"]
48362pub struct VideoQueueFamilyProperties2KHR {
48363    pub s_type: StructureType,
48364    pub p_next: *mut c_void,
48365    pub video_codec_operations: VideoCodecOperationFlagsKHR,
48366}
48367impl ::std::default::Default for VideoQueueFamilyProperties2KHR {
48368    fn default() -> Self {
48369        Self {
48370            s_type: StructureType::VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR,
48371            p_next: ::std::ptr::null_mut(),
48372            video_codec_operations: VideoCodecOperationFlagsKHR::default(),
48373        }
48374    }
48375}
48376impl VideoQueueFamilyProperties2KHR {
48377    pub fn builder<'a>() -> VideoQueueFamilyProperties2KHRBuilder<'a> {
48378        VideoQueueFamilyProperties2KHRBuilder {
48379            inner: Self::default(),
48380            marker: ::std::marker::PhantomData,
48381        }
48382    }
48383}
48384#[repr(transparent)]
48385pub struct VideoQueueFamilyProperties2KHRBuilder<'a> {
48386    inner: VideoQueueFamilyProperties2KHR,
48387    marker: ::std::marker::PhantomData<&'a ()>,
48388}
48389unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHRBuilder<'_> {}
48390unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHR {}
48391impl<'a> ::std::ops::Deref for VideoQueueFamilyProperties2KHRBuilder<'a> {
48392    type Target = VideoQueueFamilyProperties2KHR;
48393    fn deref(&self) -> &Self::Target {
48394        &self.inner
48395    }
48396}
48397impl<'a> ::std::ops::DerefMut for VideoQueueFamilyProperties2KHRBuilder<'a> {
48398    fn deref_mut(&mut self) -> &mut Self::Target {
48399        &mut self.inner
48400    }
48401}
48402impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> {
48403    pub fn video_codec_operations(
48404        mut self,
48405        video_codec_operations: VideoCodecOperationFlagsKHR,
48406    ) -> Self {
48407        self.inner.video_codec_operations = video_codec_operations;
48408        self
48409    }
48410    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48411    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48412    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48413    pub fn build(self) -> VideoQueueFamilyProperties2KHR {
48414        self.inner
48415    }
48416}
48417#[repr(C)]
48418#[cfg_attr(feature = "debug", derive(Debug))]
48419#[derive(Copy, Clone)]
48420#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyQueryResultStatusProperties2KHR.html>"]
48421pub struct QueueFamilyQueryResultStatusProperties2KHR {
48422    pub s_type: StructureType,
48423    pub p_next: *mut c_void,
48424    pub supported: Bool32,
48425}
48426impl ::std::default::Default for QueueFamilyQueryResultStatusProperties2KHR {
48427    fn default() -> Self {
48428        Self {
48429            s_type: StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR,
48430            p_next: ::std::ptr::null_mut(),
48431            supported: Bool32::default(),
48432        }
48433    }
48434}
48435impl QueueFamilyQueryResultStatusProperties2KHR {
48436    pub fn builder<'a>() -> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48437        QueueFamilyQueryResultStatusProperties2KHRBuilder {
48438            inner: Self::default(),
48439            marker: ::std::marker::PhantomData,
48440        }
48441    }
48442}
48443#[repr(transparent)]
48444pub struct QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48445    inner: QueueFamilyQueryResultStatusProperties2KHR,
48446    marker: ::std::marker::PhantomData<&'a ()>,
48447}
48448unsafe impl ExtendsQueueFamilyProperties2
48449    for QueueFamilyQueryResultStatusProperties2KHRBuilder<'_>
48450{
48451}
48452unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusProperties2KHR {}
48453impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48454    type Target = QueueFamilyQueryResultStatusProperties2KHR;
48455    fn deref(&self) -> &Self::Target {
48456        &self.inner
48457    }
48458}
48459impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48460    fn deref_mut(&mut self) -> &mut Self::Target {
48461        &mut self.inner
48462    }
48463}
48464impl<'a> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> {
48465    pub fn supported(mut self, supported: bool) -> Self {
48466        self.inner.supported = supported.into();
48467        self
48468    }
48469    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48470    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48471    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48472    pub fn build(self) -> QueueFamilyQueryResultStatusProperties2KHR {
48473        self.inner
48474    }
48475}
48476#[repr(C)]
48477#[cfg_attr(feature = "debug", derive(Debug))]
48478#[derive(Copy, Clone)]
48479#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfilesKHR.html>"]
48480pub struct VideoProfilesKHR {
48481    pub s_type: StructureType,
48482    pub p_next: *mut c_void,
48483    pub profile_count: u32,
48484    pub p_profiles: *const VideoProfileKHR,
48485}
48486impl ::std::default::Default for VideoProfilesKHR {
48487    fn default() -> Self {
48488        Self {
48489            s_type: StructureType::VIDEO_PROFILES_KHR,
48490            p_next: ::std::ptr::null_mut(),
48491            profile_count: u32::default(),
48492            p_profiles: ::std::ptr::null(),
48493        }
48494    }
48495}
48496impl VideoProfilesKHR {
48497    pub fn builder<'a>() -> VideoProfilesKHRBuilder<'a> {
48498        VideoProfilesKHRBuilder {
48499            inner: Self::default(),
48500            marker: ::std::marker::PhantomData,
48501        }
48502    }
48503}
48504#[repr(transparent)]
48505pub struct VideoProfilesKHRBuilder<'a> {
48506    inner: VideoProfilesKHR,
48507    marker: ::std::marker::PhantomData<&'a ()>,
48508}
48509unsafe impl ExtendsFormatProperties2 for VideoProfilesKHRBuilder<'_> {}
48510unsafe impl ExtendsFormatProperties2 for VideoProfilesKHR {}
48511unsafe impl ExtendsImageCreateInfo for VideoProfilesKHRBuilder<'_> {}
48512unsafe impl ExtendsImageCreateInfo for VideoProfilesKHR {}
48513unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHRBuilder<'_> {}
48514unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHR {}
48515unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHRBuilder<'_> {}
48516unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHR {}
48517impl<'a> ::std::ops::Deref for VideoProfilesKHRBuilder<'a> {
48518    type Target = VideoProfilesKHR;
48519    fn deref(&self) -> &Self::Target {
48520        &self.inner
48521    }
48522}
48523impl<'a> ::std::ops::DerefMut for VideoProfilesKHRBuilder<'a> {
48524    fn deref_mut(&mut self) -> &mut Self::Target {
48525        &mut self.inner
48526    }
48527}
48528impl<'a> VideoProfilesKHRBuilder<'a> {
48529    pub fn profiles(mut self, profiles: &'a [VideoProfileKHR]) -> Self {
48530        self.inner.profile_count = profiles.len() as _;
48531        self.inner.p_profiles = profiles.as_ptr();
48532        self
48533    }
48534    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48535    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48536    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48537    pub fn build(self) -> VideoProfilesKHR {
48538        self.inner
48539    }
48540}
48541#[repr(C)]
48542#[cfg_attr(feature = "debug", derive(Debug))]
48543#[derive(Copy, Clone)]
48544#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html>"]
48545pub struct PhysicalDeviceVideoFormatInfoKHR {
48546    pub s_type: StructureType,
48547    pub p_next: *mut c_void,
48548    pub image_usage: ImageUsageFlags,
48549    pub p_video_profiles: *const VideoProfilesKHR,
48550}
48551impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR {
48552    fn default() -> Self {
48553        Self {
48554            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
48555            p_next: ::std::ptr::null_mut(),
48556            image_usage: ImageUsageFlags::default(),
48557            p_video_profiles: ::std::ptr::null(),
48558        }
48559    }
48560}
48561impl PhysicalDeviceVideoFormatInfoKHR {
48562    pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48563        PhysicalDeviceVideoFormatInfoKHRBuilder {
48564            inner: Self::default(),
48565            marker: ::std::marker::PhantomData,
48566        }
48567    }
48568}
48569#[repr(transparent)]
48570pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48571    inner: PhysicalDeviceVideoFormatInfoKHR,
48572    marker: ::std::marker::PhantomData<&'a ()>,
48573}
48574impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48575    type Target = PhysicalDeviceVideoFormatInfoKHR;
48576    fn deref(&self) -> &Self::Target {
48577        &self.inner
48578    }
48579}
48580impl<'a> ::std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48581    fn deref_mut(&mut self) -> &mut Self::Target {
48582        &mut self.inner
48583    }
48584}
48585impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
48586    pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
48587        self.inner.image_usage = image_usage;
48588        self
48589    }
48590    pub fn video_profiles(mut self, video_profiles: &'a VideoProfilesKHR) -> Self {
48591        self.inner.p_video_profiles = video_profiles;
48592        self
48593    }
48594    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48595    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48596    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48597    pub fn build(self) -> PhysicalDeviceVideoFormatInfoKHR {
48598        self.inner
48599    }
48600}
48601#[repr(C)]
48602#[cfg_attr(feature = "debug", derive(Debug))]
48603#[derive(Copy, Clone)]
48604#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoFormatPropertiesKHR.html>"]
48605pub struct VideoFormatPropertiesKHR {
48606    pub s_type: StructureType,
48607    pub p_next: *mut c_void,
48608    pub format: Format,
48609}
48610impl ::std::default::Default for VideoFormatPropertiesKHR {
48611    fn default() -> Self {
48612        Self {
48613            s_type: StructureType::VIDEO_FORMAT_PROPERTIES_KHR,
48614            p_next: ::std::ptr::null_mut(),
48615            format: Format::default(),
48616        }
48617    }
48618}
48619impl VideoFormatPropertiesKHR {
48620    pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> {
48621        VideoFormatPropertiesKHRBuilder {
48622            inner: Self::default(),
48623            marker: ::std::marker::PhantomData,
48624        }
48625    }
48626}
48627#[repr(transparent)]
48628pub struct VideoFormatPropertiesKHRBuilder<'a> {
48629    inner: VideoFormatPropertiesKHR,
48630    marker: ::std::marker::PhantomData<&'a ()>,
48631}
48632impl<'a> ::std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> {
48633    type Target = VideoFormatPropertiesKHR;
48634    fn deref(&self) -> &Self::Target {
48635        &self.inner
48636    }
48637}
48638impl<'a> ::std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> {
48639    fn deref_mut(&mut self) -> &mut Self::Target {
48640        &mut self.inner
48641    }
48642}
48643impl<'a> VideoFormatPropertiesKHRBuilder<'a> {
48644    pub fn format(mut self, format: Format) -> Self {
48645        self.inner.format = format;
48646        self
48647    }
48648    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48649    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48650    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48651    pub fn build(self) -> VideoFormatPropertiesKHR {
48652        self.inner
48653    }
48654}
48655#[repr(C)]
48656#[cfg_attr(feature = "debug", derive(Debug))]
48657#[derive(Copy, Clone)]
48658#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileKHR.html>"]
48659pub struct VideoProfileKHR {
48660    pub s_type: StructureType,
48661    pub p_next: *mut c_void,
48662    pub video_codec_operation: VideoCodecOperationFlagsKHR,
48663    pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
48664    pub luma_bit_depth: VideoComponentBitDepthFlagsKHR,
48665    pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR,
48666}
48667impl ::std::default::Default for VideoProfileKHR {
48668    fn default() -> Self {
48669        Self {
48670            s_type: StructureType::VIDEO_PROFILE_KHR,
48671            p_next: ::std::ptr::null_mut(),
48672            video_codec_operation: VideoCodecOperationFlagsKHR::default(),
48673            chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(),
48674            luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
48675            chroma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
48676        }
48677    }
48678}
48679impl VideoProfileKHR {
48680    pub fn builder<'a>() -> VideoProfileKHRBuilder<'a> {
48681        VideoProfileKHRBuilder {
48682            inner: Self::default(),
48683            marker: ::std::marker::PhantomData,
48684        }
48685    }
48686}
48687#[repr(transparent)]
48688pub struct VideoProfileKHRBuilder<'a> {
48689    inner: VideoProfileKHR,
48690    marker: ::std::marker::PhantomData<&'a ()>,
48691}
48692unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHRBuilder<'_> {}
48693unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHR {}
48694unsafe impl ExtendsFormatProperties2 for VideoProfileKHRBuilder<'_> {}
48695unsafe impl ExtendsFormatProperties2 for VideoProfileKHR {}
48696unsafe impl ExtendsImageCreateInfo for VideoProfileKHRBuilder<'_> {}
48697unsafe impl ExtendsImageCreateInfo for VideoProfileKHR {}
48698unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHRBuilder<'_> {}
48699unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHR {}
48700unsafe impl ExtendsBufferCreateInfo for VideoProfileKHRBuilder<'_> {}
48701unsafe impl ExtendsBufferCreateInfo for VideoProfileKHR {}
48702pub unsafe trait ExtendsVideoProfileKHR {}
48703impl<'a> ::std::ops::Deref for VideoProfileKHRBuilder<'a> {
48704    type Target = VideoProfileKHR;
48705    fn deref(&self) -> &Self::Target {
48706        &self.inner
48707    }
48708}
48709impl<'a> ::std::ops::DerefMut for VideoProfileKHRBuilder<'a> {
48710    fn deref_mut(&mut self) -> &mut Self::Target {
48711        &mut self.inner
48712    }
48713}
48714impl<'a> VideoProfileKHRBuilder<'a> {
48715    pub fn video_codec_operation(
48716        mut self,
48717        video_codec_operation: VideoCodecOperationFlagsKHR,
48718    ) -> Self {
48719        self.inner.video_codec_operation = video_codec_operation;
48720        self
48721    }
48722    pub fn chroma_subsampling(
48723        mut self,
48724        chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
48725    ) -> Self {
48726        self.inner.chroma_subsampling = chroma_subsampling;
48727        self
48728    }
48729    pub fn luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
48730        self.inner.luma_bit_depth = luma_bit_depth;
48731        self
48732    }
48733    pub fn chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
48734        self.inner.chroma_bit_depth = chroma_bit_depth;
48735        self
48736    }
48737    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48738    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48739    #[doc = r" valid extension structs can be pushed into the chain."]
48740    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48741    #[doc = r" chain will look like `A -> D -> B -> C`."]
48742    pub fn push_next<T: ExtendsVideoProfileKHR>(mut self, next: &'a mut T) -> Self {
48743        unsafe {
48744            let next_ptr = <*mut T>::cast(next);
48745            let last_next = ptr_chain_iter(next).last().unwrap();
48746            (*last_next).p_next = self.inner.p_next as _;
48747            self.inner.p_next = next_ptr;
48748        }
48749        self
48750    }
48751    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48752    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48753    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48754    pub fn build(self) -> VideoProfileKHR {
48755        self.inner
48756    }
48757}
48758#[repr(C)]
48759#[cfg_attr(feature = "debug", derive(Debug))]
48760#[derive(Copy, Clone)]
48761#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilitiesKHR.html>"]
48762pub struct VideoCapabilitiesKHR {
48763    pub s_type: StructureType,
48764    pub p_next: *mut c_void,
48765    pub capability_flags: VideoCapabilityFlagsKHR,
48766    pub min_bitstream_buffer_offset_alignment: DeviceSize,
48767    pub min_bitstream_buffer_size_alignment: DeviceSize,
48768    pub video_picture_extent_granularity: Extent2D,
48769    pub min_extent: Extent2D,
48770    pub max_extent: Extent2D,
48771    pub max_reference_pictures_slots_count: u32,
48772    pub max_reference_pictures_active_count: u32,
48773    pub std_header_version: ExtensionProperties,
48774}
48775impl ::std::default::Default for VideoCapabilitiesKHR {
48776    fn default() -> Self {
48777        Self {
48778            s_type: StructureType::VIDEO_CAPABILITIES_KHR,
48779            p_next: ::std::ptr::null_mut(),
48780            capability_flags: VideoCapabilityFlagsKHR::default(),
48781            min_bitstream_buffer_offset_alignment: DeviceSize::default(),
48782            min_bitstream_buffer_size_alignment: DeviceSize::default(),
48783            video_picture_extent_granularity: Extent2D::default(),
48784            min_extent: Extent2D::default(),
48785            max_extent: Extent2D::default(),
48786            max_reference_pictures_slots_count: u32::default(),
48787            max_reference_pictures_active_count: u32::default(),
48788            std_header_version: ExtensionProperties::default(),
48789        }
48790    }
48791}
48792impl VideoCapabilitiesKHR {
48793    pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> {
48794        VideoCapabilitiesKHRBuilder {
48795            inner: Self::default(),
48796            marker: ::std::marker::PhantomData,
48797        }
48798    }
48799}
48800#[repr(transparent)]
48801pub struct VideoCapabilitiesKHRBuilder<'a> {
48802    inner: VideoCapabilitiesKHR,
48803    marker: ::std::marker::PhantomData<&'a ()>,
48804}
48805pub unsafe trait ExtendsVideoCapabilitiesKHR {}
48806impl<'a> ::std::ops::Deref for VideoCapabilitiesKHRBuilder<'a> {
48807    type Target = VideoCapabilitiesKHR;
48808    fn deref(&self) -> &Self::Target {
48809        &self.inner
48810    }
48811}
48812impl<'a> ::std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> {
48813    fn deref_mut(&mut self) -> &mut Self::Target {
48814        &mut self.inner
48815    }
48816}
48817impl<'a> VideoCapabilitiesKHRBuilder<'a> {
48818    pub fn capability_flags(mut self, capability_flags: VideoCapabilityFlagsKHR) -> Self {
48819        self.inner.capability_flags = capability_flags;
48820        self
48821    }
48822    pub fn min_bitstream_buffer_offset_alignment(
48823        mut self,
48824        min_bitstream_buffer_offset_alignment: DeviceSize,
48825    ) -> Self {
48826        self.inner.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment;
48827        self
48828    }
48829    pub fn min_bitstream_buffer_size_alignment(
48830        mut self,
48831        min_bitstream_buffer_size_alignment: DeviceSize,
48832    ) -> Self {
48833        self.inner.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment;
48834        self
48835    }
48836    pub fn video_picture_extent_granularity(
48837        mut self,
48838        video_picture_extent_granularity: Extent2D,
48839    ) -> Self {
48840        self.inner.video_picture_extent_granularity = video_picture_extent_granularity;
48841        self
48842    }
48843    pub fn min_extent(mut self, min_extent: Extent2D) -> Self {
48844        self.inner.min_extent = min_extent;
48845        self
48846    }
48847    pub fn max_extent(mut self, max_extent: Extent2D) -> Self {
48848        self.inner.max_extent = max_extent;
48849        self
48850    }
48851    pub fn max_reference_pictures_slots_count(
48852        mut self,
48853        max_reference_pictures_slots_count: u32,
48854    ) -> Self {
48855        self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count;
48856        self
48857    }
48858    pub fn max_reference_pictures_active_count(
48859        mut self,
48860        max_reference_pictures_active_count: u32,
48861    ) -> Self {
48862        self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count;
48863        self
48864    }
48865    pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self {
48866        self.inner.std_header_version = std_header_version;
48867        self
48868    }
48869    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48870    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48871    #[doc = r" valid extension structs can be pushed into the chain."]
48872    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48873    #[doc = r" chain will look like `A -> D -> B -> C`."]
48874    pub fn push_next<T: ExtendsVideoCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
48875        unsafe {
48876            let next_ptr = <*mut T>::cast(next);
48877            let last_next = ptr_chain_iter(next).last().unwrap();
48878            (*last_next).p_next = self.inner.p_next as _;
48879            self.inner.p_next = next_ptr;
48880        }
48881        self
48882    }
48883    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48884    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48885    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48886    pub fn build(self) -> VideoCapabilitiesKHR {
48887        self.inner
48888    }
48889}
48890#[repr(C)]
48891#[cfg_attr(feature = "debug", derive(Debug))]
48892#[derive(Copy, Clone)]
48893#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoGetMemoryPropertiesKHR.html>"]
48894pub struct VideoGetMemoryPropertiesKHR {
48895    pub s_type: StructureType,
48896    pub p_next: *const c_void,
48897    pub memory_bind_index: u32,
48898    pub p_memory_requirements: *mut MemoryRequirements2,
48899}
48900impl ::std::default::Default for VideoGetMemoryPropertiesKHR {
48901    fn default() -> Self {
48902        Self {
48903            s_type: StructureType::VIDEO_GET_MEMORY_PROPERTIES_KHR,
48904            p_next: ::std::ptr::null(),
48905            memory_bind_index: u32::default(),
48906            p_memory_requirements: ::std::ptr::null_mut(),
48907        }
48908    }
48909}
48910impl VideoGetMemoryPropertiesKHR {
48911    pub fn builder<'a>() -> VideoGetMemoryPropertiesKHRBuilder<'a> {
48912        VideoGetMemoryPropertiesKHRBuilder {
48913            inner: Self::default(),
48914            marker: ::std::marker::PhantomData,
48915        }
48916    }
48917}
48918#[repr(transparent)]
48919pub struct VideoGetMemoryPropertiesKHRBuilder<'a> {
48920    inner: VideoGetMemoryPropertiesKHR,
48921    marker: ::std::marker::PhantomData<&'a ()>,
48922}
48923impl<'a> ::std::ops::Deref for VideoGetMemoryPropertiesKHRBuilder<'a> {
48924    type Target = VideoGetMemoryPropertiesKHR;
48925    fn deref(&self) -> &Self::Target {
48926        &self.inner
48927    }
48928}
48929impl<'a> ::std::ops::DerefMut for VideoGetMemoryPropertiesKHRBuilder<'a> {
48930    fn deref_mut(&mut self) -> &mut Self::Target {
48931        &mut self.inner
48932    }
48933}
48934impl<'a> VideoGetMemoryPropertiesKHRBuilder<'a> {
48935    pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
48936        self.inner.memory_bind_index = memory_bind_index;
48937        self
48938    }
48939    pub fn memory_requirements(mut self, memory_requirements: &'a mut MemoryRequirements2) -> Self {
48940        self.inner.p_memory_requirements = memory_requirements;
48941        self
48942    }
48943    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48944    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48945    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
48946    pub fn build(self) -> VideoGetMemoryPropertiesKHR {
48947        self.inner
48948    }
48949}
48950#[repr(C)]
48951#[cfg_attr(feature = "debug", derive(Debug))]
48952#[derive(Copy, Clone)]
48953#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBindMemoryKHR.html>"]
48954pub struct VideoBindMemoryKHR {
48955    pub s_type: StructureType,
48956    pub p_next: *const c_void,
48957    pub memory_bind_index: u32,
48958    pub memory: DeviceMemory,
48959    pub memory_offset: DeviceSize,
48960    pub memory_size: DeviceSize,
48961}
48962impl ::std::default::Default for VideoBindMemoryKHR {
48963    fn default() -> Self {
48964        Self {
48965            s_type: StructureType::VIDEO_BIND_MEMORY_KHR,
48966            p_next: ::std::ptr::null(),
48967            memory_bind_index: u32::default(),
48968            memory: DeviceMemory::default(),
48969            memory_offset: DeviceSize::default(),
48970            memory_size: DeviceSize::default(),
48971        }
48972    }
48973}
48974impl VideoBindMemoryKHR {
48975    pub fn builder<'a>() -> VideoBindMemoryKHRBuilder<'a> {
48976        VideoBindMemoryKHRBuilder {
48977            inner: Self::default(),
48978            marker: ::std::marker::PhantomData,
48979        }
48980    }
48981}
48982#[repr(transparent)]
48983pub struct VideoBindMemoryKHRBuilder<'a> {
48984    inner: VideoBindMemoryKHR,
48985    marker: ::std::marker::PhantomData<&'a ()>,
48986}
48987impl<'a> ::std::ops::Deref for VideoBindMemoryKHRBuilder<'a> {
48988    type Target = VideoBindMemoryKHR;
48989    fn deref(&self) -> &Self::Target {
48990        &self.inner
48991    }
48992}
48993impl<'a> ::std::ops::DerefMut for VideoBindMemoryKHRBuilder<'a> {
48994    fn deref_mut(&mut self) -> &mut Self::Target {
48995        &mut self.inner
48996    }
48997}
48998impl<'a> VideoBindMemoryKHRBuilder<'a> {
48999    pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
49000        self.inner.memory_bind_index = memory_bind_index;
49001        self
49002    }
49003    pub fn memory(mut self, memory: DeviceMemory) -> Self {
49004        self.inner.memory = memory;
49005        self
49006    }
49007    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
49008        self.inner.memory_offset = memory_offset;
49009        self
49010    }
49011    pub fn memory_size(mut self, memory_size: DeviceSize) -> Self {
49012        self.inner.memory_size = memory_size;
49013        self
49014    }
49015    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49016    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49017    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49018    pub fn build(self) -> VideoBindMemoryKHR {
49019        self.inner
49020    }
49021}
49022#[repr(C)]
49023#[cfg_attr(feature = "debug", derive(Debug))]
49024#[derive(Copy, Clone)]
49025#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoPictureResourceKHR.html>"]
49026pub struct VideoPictureResourceKHR {
49027    pub s_type: StructureType,
49028    pub p_next: *const c_void,
49029    pub coded_offset: Offset2D,
49030    pub coded_extent: Extent2D,
49031    pub base_array_layer: u32,
49032    pub image_view_binding: ImageView,
49033}
49034impl ::std::default::Default for VideoPictureResourceKHR {
49035    fn default() -> Self {
49036        Self {
49037            s_type: StructureType::VIDEO_PICTURE_RESOURCE_KHR,
49038            p_next: ::std::ptr::null(),
49039            coded_offset: Offset2D::default(),
49040            coded_extent: Extent2D::default(),
49041            base_array_layer: u32::default(),
49042            image_view_binding: ImageView::default(),
49043        }
49044    }
49045}
49046impl VideoPictureResourceKHR {
49047    pub fn builder<'a>() -> VideoPictureResourceKHRBuilder<'a> {
49048        VideoPictureResourceKHRBuilder {
49049            inner: Self::default(),
49050            marker: ::std::marker::PhantomData,
49051        }
49052    }
49053}
49054#[repr(transparent)]
49055pub struct VideoPictureResourceKHRBuilder<'a> {
49056    inner: VideoPictureResourceKHR,
49057    marker: ::std::marker::PhantomData<&'a ()>,
49058}
49059impl<'a> ::std::ops::Deref for VideoPictureResourceKHRBuilder<'a> {
49060    type Target = VideoPictureResourceKHR;
49061    fn deref(&self) -> &Self::Target {
49062        &self.inner
49063    }
49064}
49065impl<'a> ::std::ops::DerefMut for VideoPictureResourceKHRBuilder<'a> {
49066    fn deref_mut(&mut self) -> &mut Self::Target {
49067        &mut self.inner
49068    }
49069}
49070impl<'a> VideoPictureResourceKHRBuilder<'a> {
49071    pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self {
49072        self.inner.coded_offset = coded_offset;
49073        self
49074    }
49075    pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
49076        self.inner.coded_extent = coded_extent;
49077        self
49078    }
49079    pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
49080        self.inner.base_array_layer = base_array_layer;
49081        self
49082    }
49083    pub fn image_view_binding(mut self, image_view_binding: ImageView) -> Self {
49084        self.inner.image_view_binding = image_view_binding;
49085        self
49086    }
49087    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49088    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49089    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49090    pub fn build(self) -> VideoPictureResourceKHR {
49091        self.inner
49092    }
49093}
49094#[repr(C)]
49095#[cfg_attr(feature = "debug", derive(Debug))]
49096#[derive(Copy, Clone)]
49097#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoReferenceSlotKHR.html>"]
49098pub struct VideoReferenceSlotKHR {
49099    pub s_type: StructureType,
49100    pub p_next: *const c_void,
49101    pub slot_index: i8,
49102    pub p_picture_resource: *const VideoPictureResourceKHR,
49103}
49104impl ::std::default::Default for VideoReferenceSlotKHR {
49105    fn default() -> Self {
49106        Self {
49107            s_type: StructureType::VIDEO_REFERENCE_SLOT_KHR,
49108            p_next: ::std::ptr::null(),
49109            slot_index: i8::default(),
49110            p_picture_resource: ::std::ptr::null(),
49111        }
49112    }
49113}
49114impl VideoReferenceSlotKHR {
49115    pub fn builder<'a>() -> VideoReferenceSlotKHRBuilder<'a> {
49116        VideoReferenceSlotKHRBuilder {
49117            inner: Self::default(),
49118            marker: ::std::marker::PhantomData,
49119        }
49120    }
49121}
49122#[repr(transparent)]
49123pub struct VideoReferenceSlotKHRBuilder<'a> {
49124    inner: VideoReferenceSlotKHR,
49125    marker: ::std::marker::PhantomData<&'a ()>,
49126}
49127pub unsafe trait ExtendsVideoReferenceSlotKHR {}
49128impl<'a> ::std::ops::Deref for VideoReferenceSlotKHRBuilder<'a> {
49129    type Target = VideoReferenceSlotKHR;
49130    fn deref(&self) -> &Self::Target {
49131        &self.inner
49132    }
49133}
49134impl<'a> ::std::ops::DerefMut for VideoReferenceSlotKHRBuilder<'a> {
49135    fn deref_mut(&mut self) -> &mut Self::Target {
49136        &mut self.inner
49137    }
49138}
49139impl<'a> VideoReferenceSlotKHRBuilder<'a> {
49140    pub fn slot_index(mut self, slot_index: i8) -> Self {
49141        self.inner.slot_index = slot_index;
49142        self
49143    }
49144    pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceKHR) -> Self {
49145        self.inner.p_picture_resource = picture_resource;
49146        self
49147    }
49148    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49149    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49150    #[doc = r" valid extension structs can be pushed into the chain."]
49151    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49152    #[doc = r" chain will look like `A -> D -> B -> C`."]
49153    pub fn push_next<T: ExtendsVideoReferenceSlotKHR>(mut self, next: &'a mut T) -> Self {
49154        unsafe {
49155            let next_ptr = <*const T>::cast(next);
49156            let last_next = ptr_chain_iter(next).last().unwrap();
49157            (*last_next).p_next = self.inner.p_next as _;
49158            self.inner.p_next = next_ptr;
49159        }
49160        self
49161    }
49162    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49163    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49164    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49165    pub fn build(self) -> VideoReferenceSlotKHR {
49166        self.inner
49167    }
49168}
49169#[repr(C)]
49170#[cfg_attr(feature = "debug", derive(Debug))]
49171#[derive(Copy, Clone)]
49172#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilitiesKHR.html>"]
49173pub struct VideoDecodeCapabilitiesKHR {
49174    pub s_type: StructureType,
49175    pub p_next: *mut c_void,
49176    pub flags: VideoDecodeCapabilityFlagsKHR,
49177}
49178impl ::std::default::Default for VideoDecodeCapabilitiesKHR {
49179    fn default() -> Self {
49180        Self {
49181            s_type: StructureType::VIDEO_DECODE_CAPABILITIES_KHR,
49182            p_next: ::std::ptr::null_mut(),
49183            flags: VideoDecodeCapabilityFlagsKHR::default(),
49184        }
49185    }
49186}
49187impl VideoDecodeCapabilitiesKHR {
49188    pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> {
49189        VideoDecodeCapabilitiesKHRBuilder {
49190            inner: Self::default(),
49191            marker: ::std::marker::PhantomData,
49192        }
49193    }
49194}
49195#[repr(transparent)]
49196pub struct VideoDecodeCapabilitiesKHRBuilder<'a> {
49197    inner: VideoDecodeCapabilitiesKHR,
49198    marker: ::std::marker::PhantomData<&'a ()>,
49199}
49200unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {}
49201unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {}
49202pub unsafe trait ExtendsVideoDecodeCapabilitiesKHR {}
49203impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> {
49204    type Target = VideoDecodeCapabilitiesKHR;
49205    fn deref(&self) -> &Self::Target {
49206        &self.inner
49207    }
49208}
49209impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> {
49210    fn deref_mut(&mut self) -> &mut Self::Target {
49211        &mut self.inner
49212    }
49213}
49214impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> {
49215    pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self {
49216        self.inner.flags = flags;
49217        self
49218    }
49219    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49220    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49221    #[doc = r" valid extension structs can be pushed into the chain."]
49222    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49223    #[doc = r" chain will look like `A -> D -> B -> C`."]
49224    pub fn push_next<T: ExtendsVideoDecodeCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
49225        unsafe {
49226            let next_ptr = <*mut T>::cast(next);
49227            let last_next = ptr_chain_iter(next).last().unwrap();
49228            (*last_next).p_next = self.inner.p_next as _;
49229            self.inner.p_next = next_ptr;
49230        }
49231        self
49232    }
49233    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49234    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49235    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49236    pub fn build(self) -> VideoDecodeCapabilitiesKHR {
49237        self.inner
49238    }
49239}
49240#[repr(C)]
49241#[cfg_attr(feature = "debug", derive(Debug))]
49242#[derive(Copy, Clone)]
49243#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeInfoKHR.html>"]
49244pub struct VideoDecodeInfoKHR {
49245    pub s_type: StructureType,
49246    pub p_next: *const c_void,
49247    pub flags: VideoDecodeFlagsKHR,
49248    pub coded_offset: Offset2D,
49249    pub coded_extent: Extent2D,
49250    pub src_buffer: Buffer,
49251    pub src_buffer_offset: DeviceSize,
49252    pub src_buffer_range: DeviceSize,
49253    pub dst_picture_resource: VideoPictureResourceKHR,
49254    pub p_setup_reference_slot: *const VideoReferenceSlotKHR,
49255    pub reference_slot_count: u32,
49256    pub p_reference_slots: *const VideoReferenceSlotKHR,
49257}
49258impl ::std::default::Default for VideoDecodeInfoKHR {
49259    fn default() -> Self {
49260        Self {
49261            s_type: StructureType::VIDEO_DECODE_INFO_KHR,
49262            p_next: ::std::ptr::null(),
49263            flags: VideoDecodeFlagsKHR::default(),
49264            coded_offset: Offset2D::default(),
49265            coded_extent: Extent2D::default(),
49266            src_buffer: Buffer::default(),
49267            src_buffer_offset: DeviceSize::default(),
49268            src_buffer_range: DeviceSize::default(),
49269            dst_picture_resource: VideoPictureResourceKHR::default(),
49270            p_setup_reference_slot: ::std::ptr::null(),
49271            reference_slot_count: u32::default(),
49272            p_reference_slots: ::std::ptr::null(),
49273        }
49274    }
49275}
49276impl VideoDecodeInfoKHR {
49277    pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> {
49278        VideoDecodeInfoKHRBuilder {
49279            inner: Self::default(),
49280            marker: ::std::marker::PhantomData,
49281        }
49282    }
49283}
49284#[repr(transparent)]
49285pub struct VideoDecodeInfoKHRBuilder<'a> {
49286    inner: VideoDecodeInfoKHR,
49287    marker: ::std::marker::PhantomData<&'a ()>,
49288}
49289pub unsafe trait ExtendsVideoDecodeInfoKHR {}
49290impl<'a> ::std::ops::Deref for VideoDecodeInfoKHRBuilder<'a> {
49291    type Target = VideoDecodeInfoKHR;
49292    fn deref(&self) -> &Self::Target {
49293        &self.inner
49294    }
49295}
49296impl<'a> ::std::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> {
49297    fn deref_mut(&mut self) -> &mut Self::Target {
49298        &mut self.inner
49299    }
49300}
49301impl<'a> VideoDecodeInfoKHRBuilder<'a> {
49302    pub fn flags(mut self, flags: VideoDecodeFlagsKHR) -> Self {
49303        self.inner.flags = flags;
49304        self
49305    }
49306    pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self {
49307        self.inner.coded_offset = coded_offset;
49308        self
49309    }
49310    pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
49311        self.inner.coded_extent = coded_extent;
49312        self
49313    }
49314    pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
49315        self.inner.src_buffer = src_buffer;
49316        self
49317    }
49318    pub fn src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self {
49319        self.inner.src_buffer_offset = src_buffer_offset;
49320        self
49321    }
49322    pub fn src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self {
49323        self.inner.src_buffer_range = src_buffer_range;
49324        self
49325    }
49326    pub fn dst_picture_resource(mut self, dst_picture_resource: VideoPictureResourceKHR) -> Self {
49327        self.inner.dst_picture_resource = dst_picture_resource;
49328        self
49329    }
49330    pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self {
49331        self.inner.p_setup_reference_slot = setup_reference_slot;
49332        self
49333    }
49334    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
49335        self.inner.reference_slot_count = reference_slots.len() as _;
49336        self.inner.p_reference_slots = reference_slots.as_ptr();
49337        self
49338    }
49339    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49340    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49341    #[doc = r" valid extension structs can be pushed into the chain."]
49342    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49343    #[doc = r" chain will look like `A -> D -> B -> C`."]
49344    pub fn push_next<T: ExtendsVideoDecodeInfoKHR>(mut self, next: &'a mut T) -> Self {
49345        unsafe {
49346            let next_ptr = <*const T>::cast(next);
49347            let last_next = ptr_chain_iter(next).last().unwrap();
49348            (*last_next).p_next = self.inner.p_next as _;
49349            self.inner.p_next = next_ptr;
49350        }
49351        self
49352    }
49353    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49354    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49355    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49356    pub fn build(self) -> VideoDecodeInfoKHR {
49357        self.inner
49358    }
49359}
49360#[repr(C)]
49361#[cfg_attr(feature = "debug", derive(Debug))]
49362#[derive(Copy, Clone)]
49363#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264ProfileEXT.html>"]
49364pub struct VideoDecodeH264ProfileEXT {
49365    pub s_type: StructureType,
49366    pub p_next: *const c_void,
49367    pub std_profile_idc: StdVideoH264ProfileIdc,
49368    pub picture_layout: VideoDecodeH264PictureLayoutFlagsEXT,
49369}
49370impl ::std::default::Default for VideoDecodeH264ProfileEXT {
49371    fn default() -> Self {
49372        Self {
49373            s_type: StructureType::VIDEO_DECODE_H264_PROFILE_EXT,
49374            p_next: ::std::ptr::null(),
49375            std_profile_idc: StdVideoH264ProfileIdc::default(),
49376            picture_layout: VideoDecodeH264PictureLayoutFlagsEXT::default(),
49377        }
49378    }
49379}
49380impl VideoDecodeH264ProfileEXT {
49381    pub fn builder<'a>() -> VideoDecodeH264ProfileEXTBuilder<'a> {
49382        VideoDecodeH264ProfileEXTBuilder {
49383            inner: Self::default(),
49384            marker: ::std::marker::PhantomData,
49385        }
49386    }
49387}
49388#[repr(transparent)]
49389pub struct VideoDecodeH264ProfileEXTBuilder<'a> {
49390    inner: VideoDecodeH264ProfileEXT,
49391    marker: ::std::marker::PhantomData<&'a ()>,
49392}
49393unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXTBuilder<'_> {}
49394unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT {}
49395unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49396unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXT {}
49397unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXTBuilder<'_> {}
49398unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXT {}
49399unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49400unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXT {}
49401unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49402unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXT {}
49403unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {}
49404unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXT {}
49405impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileEXTBuilder<'a> {
49406    type Target = VideoDecodeH264ProfileEXT;
49407    fn deref(&self) -> &Self::Target {
49408        &self.inner
49409    }
49410}
49411impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileEXTBuilder<'a> {
49412    fn deref_mut(&mut self) -> &mut Self::Target {
49413        &mut self.inner
49414    }
49415}
49416impl<'a> VideoDecodeH264ProfileEXTBuilder<'a> {
49417    pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
49418        self.inner.std_profile_idc = std_profile_idc;
49419        self
49420    }
49421    pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsEXT) -> Self {
49422        self.inner.picture_layout = picture_layout;
49423        self
49424    }
49425    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49426    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49427    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49428    pub fn build(self) -> VideoDecodeH264ProfileEXT {
49429        self.inner
49430    }
49431}
49432#[repr(C)]
49433#[cfg_attr(feature = "debug", derive(Debug))]
49434#[derive(Copy, Clone)]
49435#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264CapabilitiesEXT.html>"]
49436pub struct VideoDecodeH264CapabilitiesEXT {
49437    pub s_type: StructureType,
49438    pub p_next: *mut c_void,
49439    pub max_level: u32,
49440    pub field_offset_granularity: Offset2D,
49441}
49442impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT {
49443    fn default() -> Self {
49444        Self {
49445            s_type: StructureType::VIDEO_DECODE_H264_CAPABILITIES_EXT,
49446            p_next: ::std::ptr::null_mut(),
49447            max_level: u32::default(),
49448            field_offset_granularity: Offset2D::default(),
49449        }
49450    }
49451}
49452impl VideoDecodeH264CapabilitiesEXT {
49453    pub fn builder<'a>() -> VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49454        VideoDecodeH264CapabilitiesEXTBuilder {
49455            inner: Self::default(),
49456            marker: ::std::marker::PhantomData,
49457        }
49458    }
49459}
49460#[repr(transparent)]
49461pub struct VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49462    inner: VideoDecodeH264CapabilitiesEXT,
49463    marker: ::std::marker::PhantomData<&'a ()>,
49464}
49465unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXTBuilder<'_> {}
49466unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT {}
49467impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49468    type Target = VideoDecodeH264CapabilitiesEXT;
49469    fn deref(&self) -> &Self::Target {
49470        &self.inner
49471    }
49472}
49473impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49474    fn deref_mut(&mut self) -> &mut Self::Target {
49475        &mut self.inner
49476    }
49477}
49478impl<'a> VideoDecodeH264CapabilitiesEXTBuilder<'a> {
49479    pub fn max_level(mut self, max_level: u32) -> Self {
49480        self.inner.max_level = max_level;
49481        self
49482    }
49483    pub fn field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self {
49484        self.inner.field_offset_granularity = field_offset_granularity;
49485        self
49486    }
49487    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49488    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49489    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49490    pub fn build(self) -> VideoDecodeH264CapabilitiesEXT {
49491        self.inner
49492    }
49493}
49494#[repr(C)]
49495#[cfg_attr(feature = "debug", derive(Debug))]
49496#[derive(Copy, Clone)]
49497#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersAddInfoEXT.html>"]
49498pub struct VideoDecodeH264SessionParametersAddInfoEXT {
49499    pub s_type: StructureType,
49500    pub p_next: *const c_void,
49501    pub sps_std_count: u32,
49502    pub p_sps_std: *const StdVideoH264SequenceParameterSet,
49503    pub pps_std_count: u32,
49504    pub p_pps_std: *const StdVideoH264PictureParameterSet,
49505}
49506impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT {
49507    fn default() -> Self {
49508        Self {
49509            s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT,
49510            p_next: ::std::ptr::null(),
49511            sps_std_count: u32::default(),
49512            p_sps_std: ::std::ptr::null(),
49513            pps_std_count: u32::default(),
49514            p_pps_std: ::std::ptr::null(),
49515        }
49516    }
49517}
49518impl VideoDecodeH264SessionParametersAddInfoEXT {
49519    pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49520        VideoDecodeH264SessionParametersAddInfoEXTBuilder {
49521            inner: Self::default(),
49522            marker: ::std::marker::PhantomData,
49523        }
49524    }
49525}
49526#[repr(transparent)]
49527pub struct VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49528    inner: VideoDecodeH264SessionParametersAddInfoEXT,
49529    marker: ::std::marker::PhantomData<&'a ()>,
49530}
49531unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
49532    for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'_>
49533{
49534}
49535unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
49536    for VideoDecodeH264SessionParametersAddInfoEXT
49537{
49538}
49539impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49540    type Target = VideoDecodeH264SessionParametersAddInfoEXT;
49541    fn deref(&self) -> &Self::Target {
49542        &self.inner
49543    }
49544}
49545impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49546    fn deref_mut(&mut self) -> &mut Self::Target {
49547        &mut self.inner
49548    }
49549}
49550impl<'a> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
49551    pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self {
49552        self.inner.sps_std_count = sps_std.len() as _;
49553        self.inner.p_sps_std = sps_std.as_ptr();
49554        self
49555    }
49556    pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self {
49557        self.inner.pps_std_count = pps_std.len() as _;
49558        self.inner.p_pps_std = pps_std.as_ptr();
49559        self
49560    }
49561    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49562    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49563    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49564    pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoEXT {
49565        self.inner
49566    }
49567}
49568#[repr(C)]
49569#[cfg_attr(feature = "debug", derive(Debug))]
49570#[derive(Copy, Clone)]
49571#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersCreateInfoEXT.html>"]
49572pub struct VideoDecodeH264SessionParametersCreateInfoEXT {
49573    pub s_type: StructureType,
49574    pub p_next: *const c_void,
49575    pub max_sps_std_count: u32,
49576    pub max_pps_std_count: u32,
49577    pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoEXT,
49578}
49579impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT {
49580    fn default() -> Self {
49581        Self {
49582            s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT,
49583            p_next: ::std::ptr::null(),
49584            max_sps_std_count: u32::default(),
49585            max_pps_std_count: u32::default(),
49586            p_parameters_add_info: ::std::ptr::null(),
49587        }
49588    }
49589}
49590impl VideoDecodeH264SessionParametersCreateInfoEXT {
49591    pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49592        VideoDecodeH264SessionParametersCreateInfoEXTBuilder {
49593            inner: Self::default(),
49594            marker: ::std::marker::PhantomData,
49595        }
49596    }
49597}
49598#[repr(transparent)]
49599pub struct VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49600    inner: VideoDecodeH264SessionParametersCreateInfoEXT,
49601    marker: ::std::marker::PhantomData<&'a ()>,
49602}
49603unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
49604    for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'_>
49605{
49606}
49607unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
49608    for VideoDecodeH264SessionParametersCreateInfoEXT
49609{
49610}
49611impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49612    type Target = VideoDecodeH264SessionParametersCreateInfoEXT;
49613    fn deref(&self) -> &Self::Target {
49614        &self.inner
49615    }
49616}
49617impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49618    fn deref_mut(&mut self) -> &mut Self::Target {
49619        &mut self.inner
49620    }
49621}
49622impl<'a> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
49623    pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
49624        self.inner.max_sps_std_count = max_sps_std_count;
49625        self
49626    }
49627    pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
49628        self.inner.max_pps_std_count = max_pps_std_count;
49629        self
49630    }
49631    pub fn parameters_add_info(
49632        mut self,
49633        parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoEXT,
49634    ) -> Self {
49635        self.inner.p_parameters_add_info = parameters_add_info;
49636        self
49637    }
49638    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49639    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49640    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49641    pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoEXT {
49642        self.inner
49643    }
49644}
49645#[repr(C)]
49646#[cfg_attr(feature = "debug", derive(Debug))]
49647#[derive(Copy, Clone)]
49648#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureInfoEXT.html>"]
49649pub struct VideoDecodeH264PictureInfoEXT {
49650    pub s_type: StructureType,
49651    pub p_next: *const c_void,
49652    pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo,
49653    pub slices_count: u32,
49654    pub p_slices_data_offsets: *const u32,
49655}
49656impl ::std::default::Default for VideoDecodeH264PictureInfoEXT {
49657    fn default() -> Self {
49658        Self {
49659            s_type: StructureType::VIDEO_DECODE_H264_PICTURE_INFO_EXT,
49660            p_next: ::std::ptr::null(),
49661            p_std_picture_info: ::std::ptr::null(),
49662            slices_count: u32::default(),
49663            p_slices_data_offsets: ::std::ptr::null(),
49664        }
49665    }
49666}
49667impl VideoDecodeH264PictureInfoEXT {
49668    pub fn builder<'a>() -> VideoDecodeH264PictureInfoEXTBuilder<'a> {
49669        VideoDecodeH264PictureInfoEXTBuilder {
49670            inner: Self::default(),
49671            marker: ::std::marker::PhantomData,
49672        }
49673    }
49674}
49675#[repr(transparent)]
49676pub struct VideoDecodeH264PictureInfoEXTBuilder<'a> {
49677    inner: VideoDecodeH264PictureInfoEXT,
49678    marker: ::std::marker::PhantomData<&'a ()>,
49679}
49680unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXTBuilder<'_> {}
49681unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT {}
49682pub unsafe trait ExtendsVideoDecodeH264PictureInfoEXT {}
49683impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoEXTBuilder<'a> {
49684    type Target = VideoDecodeH264PictureInfoEXT;
49685    fn deref(&self) -> &Self::Target {
49686        &self.inner
49687    }
49688}
49689impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoEXTBuilder<'a> {
49690    fn deref_mut(&mut self) -> &mut Self::Target {
49691        &mut self.inner
49692    }
49693}
49694impl<'a> VideoDecodeH264PictureInfoEXTBuilder<'a> {
49695    pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self {
49696        self.inner.p_std_picture_info = std_picture_info;
49697        self
49698    }
49699    pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self {
49700        self.inner.slices_count = slices_data_offsets.len() as _;
49701        self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr();
49702        self
49703    }
49704    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
49705    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
49706    #[doc = r" valid extension structs can be pushed into the chain."]
49707    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
49708    #[doc = r" chain will look like `A -> D -> B -> C`."]
49709    pub fn push_next<T: ExtendsVideoDecodeH264PictureInfoEXT>(mut self, next: &'a mut T) -> Self {
49710        unsafe {
49711            let next_ptr = <*const T>::cast(next);
49712            let last_next = ptr_chain_iter(next).last().unwrap();
49713            (*last_next).p_next = self.inner.p_next as _;
49714            self.inner.p_next = next_ptr;
49715        }
49716        self
49717    }
49718    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49719    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49720    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49721    pub fn build(self) -> VideoDecodeH264PictureInfoEXT {
49722        self.inner
49723    }
49724}
49725#[repr(C)]
49726#[cfg_attr(feature = "debug", derive(Debug))]
49727#[derive(Copy, Clone)]
49728#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264DpbSlotInfoEXT.html>"]
49729pub struct VideoDecodeH264DpbSlotInfoEXT {
49730    pub s_type: StructureType,
49731    pub p_next: *const c_void,
49732    pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo,
49733}
49734impl ::std::default::Default for VideoDecodeH264DpbSlotInfoEXT {
49735    fn default() -> Self {
49736        Self {
49737            s_type: StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT,
49738            p_next: ::std::ptr::null(),
49739            p_std_reference_info: ::std::ptr::null(),
49740        }
49741    }
49742}
49743impl VideoDecodeH264DpbSlotInfoEXT {
49744    pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49745        VideoDecodeH264DpbSlotInfoEXTBuilder {
49746            inner: Self::default(),
49747            marker: ::std::marker::PhantomData,
49748        }
49749    }
49750}
49751#[repr(transparent)]
49752pub struct VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49753    inner: VideoDecodeH264DpbSlotInfoEXT,
49754    marker: ::std::marker::PhantomData<&'a ()>,
49755}
49756unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXTBuilder<'_> {}
49757unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXT {}
49758impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49759    type Target = VideoDecodeH264DpbSlotInfoEXT;
49760    fn deref(&self) -> &Self::Target {
49761        &self.inner
49762    }
49763}
49764impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49765    fn deref_mut(&mut self) -> &mut Self::Target {
49766        &mut self.inner
49767    }
49768}
49769impl<'a> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
49770    pub fn std_reference_info(
49771        mut self,
49772        std_reference_info: &'a StdVideoDecodeH264ReferenceInfo,
49773    ) -> Self {
49774        self.inner.p_std_reference_info = std_reference_info;
49775        self
49776    }
49777    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49778    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49779    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49780    pub fn build(self) -> VideoDecodeH264DpbSlotInfoEXT {
49781        self.inner
49782    }
49783}
49784#[repr(C)]
49785#[cfg_attr(feature = "debug", derive(Debug))]
49786#[derive(Copy, Clone)]
49787#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264MvcEXT.html>"]
49788pub struct VideoDecodeH264MvcEXT {
49789    pub s_type: StructureType,
49790    pub p_next: *const c_void,
49791    pub p_std_mvc: *const StdVideoDecodeH264Mvc,
49792}
49793impl ::std::default::Default for VideoDecodeH264MvcEXT {
49794    fn default() -> Self {
49795        Self {
49796            s_type: StructureType::VIDEO_DECODE_H264_MVC_EXT,
49797            p_next: ::std::ptr::null(),
49798            p_std_mvc: ::std::ptr::null(),
49799        }
49800    }
49801}
49802impl VideoDecodeH264MvcEXT {
49803    pub fn builder<'a>() -> VideoDecodeH264MvcEXTBuilder<'a> {
49804        VideoDecodeH264MvcEXTBuilder {
49805            inner: Self::default(),
49806            marker: ::std::marker::PhantomData,
49807        }
49808    }
49809}
49810#[repr(transparent)]
49811pub struct VideoDecodeH264MvcEXTBuilder<'a> {
49812    inner: VideoDecodeH264MvcEXT,
49813    marker: ::std::marker::PhantomData<&'a ()>,
49814}
49815unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXTBuilder<'_> {}
49816unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXT {}
49817impl<'a> ::std::ops::Deref for VideoDecodeH264MvcEXTBuilder<'a> {
49818    type Target = VideoDecodeH264MvcEXT;
49819    fn deref(&self) -> &Self::Target {
49820        &self.inner
49821    }
49822}
49823impl<'a> ::std::ops::DerefMut for VideoDecodeH264MvcEXTBuilder<'a> {
49824    fn deref_mut(&mut self) -> &mut Self::Target {
49825        &mut self.inner
49826    }
49827}
49828impl<'a> VideoDecodeH264MvcEXTBuilder<'a> {
49829    pub fn std_mvc(mut self, std_mvc: &'a StdVideoDecodeH264Mvc) -> Self {
49830        self.inner.p_std_mvc = std_mvc;
49831        self
49832    }
49833    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49834    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49835    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49836    pub fn build(self) -> VideoDecodeH264MvcEXT {
49837        self.inner
49838    }
49839}
49840#[repr(C)]
49841#[cfg_attr(feature = "debug", derive(Debug))]
49842#[derive(Copy, Clone)]
49843#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265ProfileEXT.html>"]
49844pub struct VideoDecodeH265ProfileEXT {
49845    pub s_type: StructureType,
49846    pub p_next: *const c_void,
49847    pub std_profile_idc: StdVideoH265ProfileIdc,
49848}
49849impl ::std::default::Default for VideoDecodeH265ProfileEXT {
49850    fn default() -> Self {
49851        Self {
49852            s_type: StructureType::VIDEO_DECODE_H265_PROFILE_EXT,
49853            p_next: ::std::ptr::null(),
49854            std_profile_idc: StdVideoH265ProfileIdc::default(),
49855        }
49856    }
49857}
49858impl VideoDecodeH265ProfileEXT {
49859    pub fn builder<'a>() -> VideoDecodeH265ProfileEXTBuilder<'a> {
49860        VideoDecodeH265ProfileEXTBuilder {
49861            inner: Self::default(),
49862            marker: ::std::marker::PhantomData,
49863        }
49864    }
49865}
49866#[repr(transparent)]
49867pub struct VideoDecodeH265ProfileEXTBuilder<'a> {
49868    inner: VideoDecodeH265ProfileEXT,
49869    marker: ::std::marker::PhantomData<&'a ()>,
49870}
49871unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXTBuilder<'_> {}
49872unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT {}
49873unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49874unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXT {}
49875unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXTBuilder<'_> {}
49876unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXT {}
49877unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49878unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXT {}
49879unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49880unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXT {}
49881unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {}
49882unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXT {}
49883impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileEXTBuilder<'a> {
49884    type Target = VideoDecodeH265ProfileEXT;
49885    fn deref(&self) -> &Self::Target {
49886        &self.inner
49887    }
49888}
49889impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileEXTBuilder<'a> {
49890    fn deref_mut(&mut self) -> &mut Self::Target {
49891        &mut self.inner
49892    }
49893}
49894impl<'a> VideoDecodeH265ProfileEXTBuilder<'a> {
49895    pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
49896        self.inner.std_profile_idc = std_profile_idc;
49897        self
49898    }
49899    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49900    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49901    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49902    pub fn build(self) -> VideoDecodeH265ProfileEXT {
49903        self.inner
49904    }
49905}
49906#[repr(C)]
49907#[cfg_attr(feature = "debug", derive(Debug))]
49908#[derive(Copy, Clone)]
49909#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265CapabilitiesEXT.html>"]
49910pub struct VideoDecodeH265CapabilitiesEXT {
49911    pub s_type: StructureType,
49912    pub p_next: *mut c_void,
49913    pub max_level: u32,
49914}
49915impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT {
49916    fn default() -> Self {
49917        Self {
49918            s_type: StructureType::VIDEO_DECODE_H265_CAPABILITIES_EXT,
49919            p_next: ::std::ptr::null_mut(),
49920            max_level: u32::default(),
49921        }
49922    }
49923}
49924impl VideoDecodeH265CapabilitiesEXT {
49925    pub fn builder<'a>() -> VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49926        VideoDecodeH265CapabilitiesEXTBuilder {
49927            inner: Self::default(),
49928            marker: ::std::marker::PhantomData,
49929        }
49930    }
49931}
49932#[repr(transparent)]
49933pub struct VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49934    inner: VideoDecodeH265CapabilitiesEXT,
49935    marker: ::std::marker::PhantomData<&'a ()>,
49936}
49937unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXTBuilder<'_> {}
49938unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT {}
49939impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49940    type Target = VideoDecodeH265CapabilitiesEXT;
49941    fn deref(&self) -> &Self::Target {
49942        &self.inner
49943    }
49944}
49945impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49946    fn deref_mut(&mut self) -> &mut Self::Target {
49947        &mut self.inner
49948    }
49949}
49950impl<'a> VideoDecodeH265CapabilitiesEXTBuilder<'a> {
49951    pub fn max_level(mut self, max_level: u32) -> Self {
49952        self.inner.max_level = max_level;
49953        self
49954    }
49955    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49956    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49957    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
49958    pub fn build(self) -> VideoDecodeH265CapabilitiesEXT {
49959        self.inner
49960    }
49961}
49962#[repr(C)]
49963#[cfg_attr(feature = "debug", derive(Debug))]
49964#[derive(Copy, Clone)]
49965#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersAddInfoEXT.html>"]
49966pub struct VideoDecodeH265SessionParametersAddInfoEXT {
49967    pub s_type: StructureType,
49968    pub p_next: *const c_void,
49969    pub vps_std_count: u32,
49970    pub p_vps_std: *const StdVideoH265VideoParameterSet,
49971    pub sps_std_count: u32,
49972    pub p_sps_std: *const StdVideoH265SequenceParameterSet,
49973    pub pps_std_count: u32,
49974    pub p_pps_std: *const StdVideoH265PictureParameterSet,
49975}
49976impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT {
49977    fn default() -> Self {
49978        Self {
49979            s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT,
49980            p_next: ::std::ptr::null(),
49981            vps_std_count: u32::default(),
49982            p_vps_std: ::std::ptr::null(),
49983            sps_std_count: u32::default(),
49984            p_sps_std: ::std::ptr::null(),
49985            pps_std_count: u32::default(),
49986            p_pps_std: ::std::ptr::null(),
49987        }
49988    }
49989}
49990impl VideoDecodeH265SessionParametersAddInfoEXT {
49991    pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
49992        VideoDecodeH265SessionParametersAddInfoEXTBuilder {
49993            inner: Self::default(),
49994            marker: ::std::marker::PhantomData,
49995        }
49996    }
49997}
49998#[repr(transparent)]
49999pub struct VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50000    inner: VideoDecodeH265SessionParametersAddInfoEXT,
50001    marker: ::std::marker::PhantomData<&'a ()>,
50002}
50003unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
50004    for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'_>
50005{
50006}
50007unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
50008    for VideoDecodeH265SessionParametersAddInfoEXT
50009{
50010}
50011impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50012    type Target = VideoDecodeH265SessionParametersAddInfoEXT;
50013    fn deref(&self) -> &Self::Target {
50014        &self.inner
50015    }
50016}
50017impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50018    fn deref_mut(&mut self) -> &mut Self::Target {
50019        &mut self.inner
50020    }
50021}
50022impl<'a> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
50023    pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self {
50024        self.inner.vps_std_count = vps_std.len() as _;
50025        self.inner.p_vps_std = vps_std.as_ptr();
50026        self
50027    }
50028    pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self {
50029        self.inner.sps_std_count = sps_std.len() as _;
50030        self.inner.p_sps_std = sps_std.as_ptr();
50031        self
50032    }
50033    pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self {
50034        self.inner.pps_std_count = pps_std.len() as _;
50035        self.inner.p_pps_std = pps_std.as_ptr();
50036        self
50037    }
50038    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50039    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50040    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50041    pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoEXT {
50042        self.inner
50043    }
50044}
50045#[repr(C)]
50046#[cfg_attr(feature = "debug", derive(Debug))]
50047#[derive(Copy, Clone)]
50048#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersCreateInfoEXT.html>"]
50049pub struct VideoDecodeH265SessionParametersCreateInfoEXT {
50050    pub s_type: StructureType,
50051    pub p_next: *const c_void,
50052    pub max_vps_std_count: u32,
50053    pub max_sps_std_count: u32,
50054    pub max_pps_std_count: u32,
50055    pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT,
50056}
50057impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT {
50058    fn default() -> Self {
50059        Self {
50060            s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT,
50061            p_next: ::std::ptr::null(),
50062            max_vps_std_count: u32::default(),
50063            max_sps_std_count: u32::default(),
50064            max_pps_std_count: u32::default(),
50065            p_parameters_add_info: ::std::ptr::null(),
50066        }
50067    }
50068}
50069impl VideoDecodeH265SessionParametersCreateInfoEXT {
50070    pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50071        VideoDecodeH265SessionParametersCreateInfoEXTBuilder {
50072            inner: Self::default(),
50073            marker: ::std::marker::PhantomData,
50074        }
50075    }
50076}
50077#[repr(transparent)]
50078pub struct VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50079    inner: VideoDecodeH265SessionParametersCreateInfoEXT,
50080    marker: ::std::marker::PhantomData<&'a ()>,
50081}
50082unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
50083    for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'_>
50084{
50085}
50086unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
50087    for VideoDecodeH265SessionParametersCreateInfoEXT
50088{
50089}
50090impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50091    type Target = VideoDecodeH265SessionParametersCreateInfoEXT;
50092    fn deref(&self) -> &Self::Target {
50093        &self.inner
50094    }
50095}
50096impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50097    fn deref_mut(&mut self) -> &mut Self::Target {
50098        &mut self.inner
50099    }
50100}
50101impl<'a> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
50102    pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self {
50103        self.inner.max_vps_std_count = max_vps_std_count;
50104        self
50105    }
50106    pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
50107        self.inner.max_sps_std_count = max_sps_std_count;
50108        self
50109    }
50110    pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
50111        self.inner.max_pps_std_count = max_pps_std_count;
50112        self
50113    }
50114    pub fn parameters_add_info(
50115        mut self,
50116        parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoEXT,
50117    ) -> Self {
50118        self.inner.p_parameters_add_info = parameters_add_info;
50119        self
50120    }
50121    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50122    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50123    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50124    pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoEXT {
50125        self.inner
50126    }
50127}
50128#[repr(C)]
50129#[cfg_attr(feature = "debug", derive(Debug))]
50130#[derive(Copy, Clone)]
50131#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265PictureInfoEXT.html>"]
50132pub struct VideoDecodeH265PictureInfoEXT {
50133    pub s_type: StructureType,
50134    pub p_next: *const c_void,
50135    pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo,
50136    pub slices_count: u32,
50137    pub p_slices_data_offsets: *const u32,
50138}
50139impl ::std::default::Default for VideoDecodeH265PictureInfoEXT {
50140    fn default() -> Self {
50141        Self {
50142            s_type: StructureType::VIDEO_DECODE_H265_PICTURE_INFO_EXT,
50143            p_next: ::std::ptr::null(),
50144            p_std_picture_info: ::std::ptr::null_mut(),
50145            slices_count: u32::default(),
50146            p_slices_data_offsets: ::std::ptr::null(),
50147        }
50148    }
50149}
50150impl VideoDecodeH265PictureInfoEXT {
50151    pub fn builder<'a>() -> VideoDecodeH265PictureInfoEXTBuilder<'a> {
50152        VideoDecodeH265PictureInfoEXTBuilder {
50153            inner: Self::default(),
50154            marker: ::std::marker::PhantomData,
50155        }
50156    }
50157}
50158#[repr(transparent)]
50159pub struct VideoDecodeH265PictureInfoEXTBuilder<'a> {
50160    inner: VideoDecodeH265PictureInfoEXT,
50161    marker: ::std::marker::PhantomData<&'a ()>,
50162}
50163unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXTBuilder<'_> {}
50164unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXT {}
50165impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoEXTBuilder<'a> {
50166    type Target = VideoDecodeH265PictureInfoEXT;
50167    fn deref(&self) -> &Self::Target {
50168        &self.inner
50169    }
50170}
50171impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoEXTBuilder<'a> {
50172    fn deref_mut(&mut self) -> &mut Self::Target {
50173        &mut self.inner
50174    }
50175}
50176impl<'a> VideoDecodeH265PictureInfoEXTBuilder<'a> {
50177    pub fn std_picture_info(
50178        mut self,
50179        std_picture_info: &'a mut StdVideoDecodeH265PictureInfo,
50180    ) -> Self {
50181        self.inner.p_std_picture_info = std_picture_info;
50182        self
50183    }
50184    pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self {
50185        self.inner.slices_count = slices_data_offsets.len() as _;
50186        self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr();
50187        self
50188    }
50189    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50190    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50191    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50192    pub fn build(self) -> VideoDecodeH265PictureInfoEXT {
50193        self.inner
50194    }
50195}
50196#[repr(C)]
50197#[cfg_attr(feature = "debug", derive(Debug))]
50198#[derive(Copy, Clone)]
50199#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265DpbSlotInfoEXT.html>"]
50200pub struct VideoDecodeH265DpbSlotInfoEXT {
50201    pub s_type: StructureType,
50202    pub p_next: *const c_void,
50203    pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo,
50204}
50205impl ::std::default::Default for VideoDecodeH265DpbSlotInfoEXT {
50206    fn default() -> Self {
50207        Self {
50208            s_type: StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT,
50209            p_next: ::std::ptr::null(),
50210            p_std_reference_info: ::std::ptr::null(),
50211        }
50212    }
50213}
50214impl VideoDecodeH265DpbSlotInfoEXT {
50215    pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50216        VideoDecodeH265DpbSlotInfoEXTBuilder {
50217            inner: Self::default(),
50218            marker: ::std::marker::PhantomData,
50219        }
50220    }
50221}
50222#[repr(transparent)]
50223pub struct VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50224    inner: VideoDecodeH265DpbSlotInfoEXT,
50225    marker: ::std::marker::PhantomData<&'a ()>,
50226}
50227unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXTBuilder<'_> {}
50228unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXT {}
50229impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50230    type Target = VideoDecodeH265DpbSlotInfoEXT;
50231    fn deref(&self) -> &Self::Target {
50232        &self.inner
50233    }
50234}
50235impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50236    fn deref_mut(&mut self) -> &mut Self::Target {
50237        &mut self.inner
50238    }
50239}
50240impl<'a> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
50241    pub fn std_reference_info(
50242        mut self,
50243        std_reference_info: &'a StdVideoDecodeH265ReferenceInfo,
50244    ) -> Self {
50245        self.inner.p_std_reference_info = std_reference_info;
50246        self
50247    }
50248    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50249    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50250    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50251    pub fn build(self) -> VideoDecodeH265DpbSlotInfoEXT {
50252        self.inner
50253    }
50254}
50255#[repr(C)]
50256#[cfg_attr(feature = "debug", derive(Debug))]
50257#[derive(Copy, Clone)]
50258#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateInfoKHR.html>"]
50259pub struct VideoSessionCreateInfoKHR {
50260    pub s_type: StructureType,
50261    pub p_next: *const c_void,
50262    pub queue_family_index: u32,
50263    pub flags: VideoSessionCreateFlagsKHR,
50264    pub p_video_profile: *const VideoProfileKHR,
50265    pub picture_format: Format,
50266    pub max_coded_extent: Extent2D,
50267    pub reference_pictures_format: Format,
50268    pub max_reference_pictures_slots_count: u32,
50269    pub max_reference_pictures_active_count: u32,
50270    pub p_std_header_version: *const ExtensionProperties,
50271}
50272impl ::std::default::Default for VideoSessionCreateInfoKHR {
50273    fn default() -> Self {
50274        Self {
50275            s_type: StructureType::VIDEO_SESSION_CREATE_INFO_KHR,
50276            p_next: ::std::ptr::null(),
50277            queue_family_index: u32::default(),
50278            flags: VideoSessionCreateFlagsKHR::default(),
50279            p_video_profile: ::std::ptr::null(),
50280            picture_format: Format::default(),
50281            max_coded_extent: Extent2D::default(),
50282            reference_pictures_format: Format::default(),
50283            max_reference_pictures_slots_count: u32::default(),
50284            max_reference_pictures_active_count: u32::default(),
50285            p_std_header_version: ::std::ptr::null(),
50286        }
50287    }
50288}
50289impl VideoSessionCreateInfoKHR {
50290    pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> {
50291        VideoSessionCreateInfoKHRBuilder {
50292            inner: Self::default(),
50293            marker: ::std::marker::PhantomData,
50294        }
50295    }
50296}
50297#[repr(transparent)]
50298pub struct VideoSessionCreateInfoKHRBuilder<'a> {
50299    inner: VideoSessionCreateInfoKHR,
50300    marker: ::std::marker::PhantomData<&'a ()>,
50301}
50302impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> {
50303    type Target = VideoSessionCreateInfoKHR;
50304    fn deref(&self) -> &Self::Target {
50305        &self.inner
50306    }
50307}
50308impl<'a> ::std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> {
50309    fn deref_mut(&mut self) -> &mut Self::Target {
50310        &mut self.inner
50311    }
50312}
50313impl<'a> VideoSessionCreateInfoKHRBuilder<'a> {
50314    pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
50315        self.inner.queue_family_index = queue_family_index;
50316        self
50317    }
50318    pub fn flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self {
50319        self.inner.flags = flags;
50320        self
50321    }
50322    pub fn video_profile(mut self, video_profile: &'a VideoProfileKHR) -> Self {
50323        self.inner.p_video_profile = video_profile;
50324        self
50325    }
50326    pub fn picture_format(mut self, picture_format: Format) -> Self {
50327        self.inner.picture_format = picture_format;
50328        self
50329    }
50330    pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self {
50331        self.inner.max_coded_extent = max_coded_extent;
50332        self
50333    }
50334    pub fn reference_pictures_format(mut self, reference_pictures_format: Format) -> Self {
50335        self.inner.reference_pictures_format = reference_pictures_format;
50336        self
50337    }
50338    pub fn max_reference_pictures_slots_count(
50339        mut self,
50340        max_reference_pictures_slots_count: u32,
50341    ) -> Self {
50342        self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count;
50343        self
50344    }
50345    pub fn max_reference_pictures_active_count(
50346        mut self,
50347        max_reference_pictures_active_count: u32,
50348    ) -> Self {
50349        self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count;
50350        self
50351    }
50352    pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self {
50353        self.inner.p_std_header_version = std_header_version;
50354        self
50355    }
50356    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50357    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50358    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50359    pub fn build(self) -> VideoSessionCreateInfoKHR {
50360        self.inner
50361    }
50362}
50363#[repr(C)]
50364#[cfg_attr(feature = "debug", derive(Debug))]
50365#[derive(Copy, Clone)]
50366#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html>"]
50367pub struct VideoSessionParametersCreateInfoKHR {
50368    pub s_type: StructureType,
50369    pub p_next: *const c_void,
50370    pub video_session_parameters_template: VideoSessionParametersKHR,
50371    pub video_session: VideoSessionKHR,
50372}
50373impl ::std::default::Default for VideoSessionParametersCreateInfoKHR {
50374    fn default() -> Self {
50375        Self {
50376            s_type: StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
50377            p_next: ::std::ptr::null(),
50378            video_session_parameters_template: VideoSessionParametersKHR::default(),
50379            video_session: VideoSessionKHR::default(),
50380        }
50381    }
50382}
50383impl VideoSessionParametersCreateInfoKHR {
50384    pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
50385        VideoSessionParametersCreateInfoKHRBuilder {
50386            inner: Self::default(),
50387            marker: ::std::marker::PhantomData,
50388        }
50389    }
50390}
50391#[repr(transparent)]
50392pub struct VideoSessionParametersCreateInfoKHRBuilder<'a> {
50393    inner: VideoSessionParametersCreateInfoKHR,
50394    marker: ::std::marker::PhantomData<&'a ()>,
50395}
50396pub unsafe trait ExtendsVideoSessionParametersCreateInfoKHR {}
50397impl<'a> ::std::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> {
50398    type Target = VideoSessionParametersCreateInfoKHR;
50399    fn deref(&self) -> &Self::Target {
50400        &self.inner
50401    }
50402}
50403impl<'a> ::std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> {
50404    fn deref_mut(&mut self) -> &mut Self::Target {
50405        &mut self.inner
50406    }
50407}
50408impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
50409    pub fn video_session_parameters_template(
50410        mut self,
50411        video_session_parameters_template: VideoSessionParametersKHR,
50412    ) -> Self {
50413        self.inner.video_session_parameters_template = video_session_parameters_template;
50414        self
50415    }
50416    pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
50417        self.inner.video_session = video_session;
50418        self
50419    }
50420    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50421    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50422    #[doc = r" valid extension structs can be pushed into the chain."]
50423    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50424    #[doc = r" chain will look like `A -> D -> B -> C`."]
50425    pub fn push_next<T: ExtendsVideoSessionParametersCreateInfoKHR>(
50426        mut self,
50427        next: &'a mut T,
50428    ) -> Self {
50429        unsafe {
50430            let next_ptr = <*const T>::cast(next);
50431            let last_next = ptr_chain_iter(next).last().unwrap();
50432            (*last_next).p_next = self.inner.p_next as _;
50433            self.inner.p_next = next_ptr;
50434        }
50435        self
50436    }
50437    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50438    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50439    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50440    pub fn build(self) -> VideoSessionParametersCreateInfoKHR {
50441        self.inner
50442    }
50443}
50444#[repr(C)]
50445#[cfg_attr(feature = "debug", derive(Debug))]
50446#[derive(Copy, Clone)]
50447#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html>"]
50448pub struct VideoSessionParametersUpdateInfoKHR {
50449    pub s_type: StructureType,
50450    pub p_next: *const c_void,
50451    pub update_sequence_count: u32,
50452}
50453impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR {
50454    fn default() -> Self {
50455        Self {
50456            s_type: StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR,
50457            p_next: ::std::ptr::null(),
50458            update_sequence_count: u32::default(),
50459        }
50460    }
50461}
50462impl VideoSessionParametersUpdateInfoKHR {
50463    pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50464        VideoSessionParametersUpdateInfoKHRBuilder {
50465            inner: Self::default(),
50466            marker: ::std::marker::PhantomData,
50467        }
50468    }
50469}
50470#[repr(transparent)]
50471pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50472    inner: VideoSessionParametersUpdateInfoKHR,
50473    marker: ::std::marker::PhantomData<&'a ()>,
50474}
50475pub unsafe trait ExtendsVideoSessionParametersUpdateInfoKHR {}
50476impl<'a> ::std::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50477    type Target = VideoSessionParametersUpdateInfoKHR;
50478    fn deref(&self) -> &Self::Target {
50479        &self.inner
50480    }
50481}
50482impl<'a> ::std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50483    fn deref_mut(&mut self) -> &mut Self::Target {
50484        &mut self.inner
50485    }
50486}
50487impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
50488    pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self {
50489        self.inner.update_sequence_count = update_sequence_count;
50490        self
50491    }
50492    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50493    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50494    #[doc = r" valid extension structs can be pushed into the chain."]
50495    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50496    #[doc = r" chain will look like `A -> D -> B -> C`."]
50497    pub fn push_next<T: ExtendsVideoSessionParametersUpdateInfoKHR>(
50498        mut self,
50499        next: &'a mut T,
50500    ) -> Self {
50501        unsafe {
50502            let next_ptr = <*const T>::cast(next);
50503            let last_next = ptr_chain_iter(next).last().unwrap();
50504            (*last_next).p_next = self.inner.p_next as _;
50505            self.inner.p_next = next_ptr;
50506        }
50507        self
50508    }
50509    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50510    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50511    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50512    pub fn build(self) -> VideoSessionParametersUpdateInfoKHR {
50513        self.inner
50514    }
50515}
50516#[repr(C)]
50517#[cfg_attr(feature = "debug", derive(Debug))]
50518#[derive(Copy, Clone)]
50519#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingInfoKHR.html>"]
50520pub struct VideoBeginCodingInfoKHR {
50521    pub s_type: StructureType,
50522    pub p_next: *const c_void,
50523    pub flags: VideoBeginCodingFlagsKHR,
50524    pub codec_quality_preset: VideoCodingQualityPresetFlagsKHR,
50525    pub video_session: VideoSessionKHR,
50526    pub video_session_parameters: VideoSessionParametersKHR,
50527    pub reference_slot_count: u32,
50528    pub p_reference_slots: *const VideoReferenceSlotKHR,
50529}
50530impl ::std::default::Default for VideoBeginCodingInfoKHR {
50531    fn default() -> Self {
50532        Self {
50533            s_type: StructureType::VIDEO_BEGIN_CODING_INFO_KHR,
50534            p_next: ::std::ptr::null(),
50535            flags: VideoBeginCodingFlagsKHR::default(),
50536            codec_quality_preset: VideoCodingQualityPresetFlagsKHR::default(),
50537            video_session: VideoSessionKHR::default(),
50538            video_session_parameters: VideoSessionParametersKHR::default(),
50539            reference_slot_count: u32::default(),
50540            p_reference_slots: ::std::ptr::null(),
50541        }
50542    }
50543}
50544impl VideoBeginCodingInfoKHR {
50545    pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> {
50546        VideoBeginCodingInfoKHRBuilder {
50547            inner: Self::default(),
50548            marker: ::std::marker::PhantomData,
50549        }
50550    }
50551}
50552#[repr(transparent)]
50553pub struct VideoBeginCodingInfoKHRBuilder<'a> {
50554    inner: VideoBeginCodingInfoKHR,
50555    marker: ::std::marker::PhantomData<&'a ()>,
50556}
50557impl<'a> ::std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> {
50558    type Target = VideoBeginCodingInfoKHR;
50559    fn deref(&self) -> &Self::Target {
50560        &self.inner
50561    }
50562}
50563impl<'a> ::std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> {
50564    fn deref_mut(&mut self) -> &mut Self::Target {
50565        &mut self.inner
50566    }
50567}
50568impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
50569    pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self {
50570        self.inner.flags = flags;
50571        self
50572    }
50573    pub fn codec_quality_preset(
50574        mut self,
50575        codec_quality_preset: VideoCodingQualityPresetFlagsKHR,
50576    ) -> Self {
50577        self.inner.codec_quality_preset = codec_quality_preset;
50578        self
50579    }
50580    pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
50581        self.inner.video_session = video_session;
50582        self
50583    }
50584    pub fn video_session_parameters(
50585        mut self,
50586        video_session_parameters: VideoSessionParametersKHR,
50587    ) -> Self {
50588        self.inner.video_session_parameters = video_session_parameters;
50589        self
50590    }
50591    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
50592        self.inner.reference_slot_count = reference_slots.len() as _;
50593        self.inner.p_reference_slots = reference_slots.as_ptr();
50594        self
50595    }
50596    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50597    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50598    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50599    pub fn build(self) -> VideoBeginCodingInfoKHR {
50600        self.inner
50601    }
50602}
50603#[repr(C)]
50604#[cfg_attr(feature = "debug", derive(Debug))]
50605#[derive(Copy, Clone)]
50606#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingInfoKHR.html>"]
50607pub struct VideoEndCodingInfoKHR {
50608    pub s_type: StructureType,
50609    pub p_next: *const c_void,
50610    pub flags: VideoEndCodingFlagsKHR,
50611}
50612impl ::std::default::Default for VideoEndCodingInfoKHR {
50613    fn default() -> Self {
50614        Self {
50615            s_type: StructureType::VIDEO_END_CODING_INFO_KHR,
50616            p_next: ::std::ptr::null(),
50617            flags: VideoEndCodingFlagsKHR::default(),
50618        }
50619    }
50620}
50621impl VideoEndCodingInfoKHR {
50622    pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> {
50623        VideoEndCodingInfoKHRBuilder {
50624            inner: Self::default(),
50625            marker: ::std::marker::PhantomData,
50626        }
50627    }
50628}
50629#[repr(transparent)]
50630pub struct VideoEndCodingInfoKHRBuilder<'a> {
50631    inner: VideoEndCodingInfoKHR,
50632    marker: ::std::marker::PhantomData<&'a ()>,
50633}
50634impl<'a> ::std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> {
50635    type Target = VideoEndCodingInfoKHR;
50636    fn deref(&self) -> &Self::Target {
50637        &self.inner
50638    }
50639}
50640impl<'a> ::std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> {
50641    fn deref_mut(&mut self) -> &mut Self::Target {
50642        &mut self.inner
50643    }
50644}
50645impl<'a> VideoEndCodingInfoKHRBuilder<'a> {
50646    pub fn flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self {
50647        self.inner.flags = flags;
50648        self
50649    }
50650    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50651    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50652    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50653    pub fn build(self) -> VideoEndCodingInfoKHR {
50654        self.inner
50655    }
50656}
50657#[repr(C)]
50658#[cfg_attr(feature = "debug", derive(Debug))]
50659#[derive(Copy, Clone)]
50660#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlInfoKHR.html>"]
50661pub struct VideoCodingControlInfoKHR {
50662    pub s_type: StructureType,
50663    pub p_next: *const c_void,
50664    pub flags: VideoCodingControlFlagsKHR,
50665}
50666impl ::std::default::Default for VideoCodingControlInfoKHR {
50667    fn default() -> Self {
50668        Self {
50669            s_type: StructureType::VIDEO_CODING_CONTROL_INFO_KHR,
50670            p_next: ::std::ptr::null(),
50671            flags: VideoCodingControlFlagsKHR::default(),
50672        }
50673    }
50674}
50675impl VideoCodingControlInfoKHR {
50676    pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> {
50677        VideoCodingControlInfoKHRBuilder {
50678            inner: Self::default(),
50679            marker: ::std::marker::PhantomData,
50680        }
50681    }
50682}
50683#[repr(transparent)]
50684pub struct VideoCodingControlInfoKHRBuilder<'a> {
50685    inner: VideoCodingControlInfoKHR,
50686    marker: ::std::marker::PhantomData<&'a ()>,
50687}
50688pub unsafe trait ExtendsVideoCodingControlInfoKHR {}
50689impl<'a> ::std::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> {
50690    type Target = VideoCodingControlInfoKHR;
50691    fn deref(&self) -> &Self::Target {
50692        &self.inner
50693    }
50694}
50695impl<'a> ::std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> {
50696    fn deref_mut(&mut self) -> &mut Self::Target {
50697        &mut self.inner
50698    }
50699}
50700impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
50701    pub fn flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self {
50702        self.inner.flags = flags;
50703        self
50704    }
50705    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50706    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50707    #[doc = r" valid extension structs can be pushed into the chain."]
50708    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50709    #[doc = r" chain will look like `A -> D -> B -> C`."]
50710    pub fn push_next<T: ExtendsVideoCodingControlInfoKHR>(mut self, next: &'a mut T) -> Self {
50711        unsafe {
50712            let next_ptr = <*const T>::cast(next);
50713            let last_next = ptr_chain_iter(next).last().unwrap();
50714            (*last_next).p_next = self.inner.p_next as _;
50715            self.inner.p_next = next_ptr;
50716        }
50717        self
50718    }
50719    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50720    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50721    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50722    pub fn build(self) -> VideoCodingControlInfoKHR {
50723        self.inner
50724    }
50725}
50726#[repr(C)]
50727#[cfg_attr(feature = "debug", derive(Debug))]
50728#[derive(Copy, Clone)]
50729#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeInfoKHR.html>"]
50730pub struct VideoEncodeInfoKHR {
50731    pub s_type: StructureType,
50732    pub p_next: *const c_void,
50733    pub flags: VideoEncodeFlagsKHR,
50734    pub quality_level: u32,
50735    pub coded_extent: Extent2D,
50736    pub dst_bitstream_buffer: Buffer,
50737    pub dst_bitstream_buffer_offset: DeviceSize,
50738    pub dst_bitstream_buffer_max_range: DeviceSize,
50739    pub src_picture_resource: VideoPictureResourceKHR,
50740    pub p_setup_reference_slot: *const VideoReferenceSlotKHR,
50741    pub reference_slot_count: u32,
50742    pub p_reference_slots: *const VideoReferenceSlotKHR,
50743    pub preceding_externally_encoded_bytes: u32,
50744}
50745impl ::std::default::Default for VideoEncodeInfoKHR {
50746    fn default() -> Self {
50747        Self {
50748            s_type: StructureType::VIDEO_ENCODE_INFO_KHR,
50749            p_next: ::std::ptr::null(),
50750            flags: VideoEncodeFlagsKHR::default(),
50751            quality_level: u32::default(),
50752            coded_extent: Extent2D::default(),
50753            dst_bitstream_buffer: Buffer::default(),
50754            dst_bitstream_buffer_offset: DeviceSize::default(),
50755            dst_bitstream_buffer_max_range: DeviceSize::default(),
50756            src_picture_resource: VideoPictureResourceKHR::default(),
50757            p_setup_reference_slot: ::std::ptr::null(),
50758            reference_slot_count: u32::default(),
50759            p_reference_slots: ::std::ptr::null(),
50760            preceding_externally_encoded_bytes: u32::default(),
50761        }
50762    }
50763}
50764impl VideoEncodeInfoKHR {
50765    pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> {
50766        VideoEncodeInfoKHRBuilder {
50767            inner: Self::default(),
50768            marker: ::std::marker::PhantomData,
50769        }
50770    }
50771}
50772#[repr(transparent)]
50773pub struct VideoEncodeInfoKHRBuilder<'a> {
50774    inner: VideoEncodeInfoKHR,
50775    marker: ::std::marker::PhantomData<&'a ()>,
50776}
50777pub unsafe trait ExtendsVideoEncodeInfoKHR {}
50778impl<'a> ::std::ops::Deref for VideoEncodeInfoKHRBuilder<'a> {
50779    type Target = VideoEncodeInfoKHR;
50780    fn deref(&self) -> &Self::Target {
50781        &self.inner
50782    }
50783}
50784impl<'a> ::std::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> {
50785    fn deref_mut(&mut self) -> &mut Self::Target {
50786        &mut self.inner
50787    }
50788}
50789impl<'a> VideoEncodeInfoKHRBuilder<'a> {
50790    pub fn flags(mut self, flags: VideoEncodeFlagsKHR) -> Self {
50791        self.inner.flags = flags;
50792        self
50793    }
50794    pub fn quality_level(mut self, quality_level: u32) -> Self {
50795        self.inner.quality_level = quality_level;
50796        self
50797    }
50798    pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
50799        self.inner.coded_extent = coded_extent;
50800        self
50801    }
50802    pub fn dst_bitstream_buffer(mut self, dst_bitstream_buffer: Buffer) -> Self {
50803        self.inner.dst_bitstream_buffer = dst_bitstream_buffer;
50804        self
50805    }
50806    pub fn dst_bitstream_buffer_offset(mut self, dst_bitstream_buffer_offset: DeviceSize) -> Self {
50807        self.inner.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset;
50808        self
50809    }
50810    pub fn dst_bitstream_buffer_max_range(
50811        mut self,
50812        dst_bitstream_buffer_max_range: DeviceSize,
50813    ) -> Self {
50814        self.inner.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range;
50815        self
50816    }
50817    pub fn src_picture_resource(mut self, src_picture_resource: VideoPictureResourceKHR) -> Self {
50818        self.inner.src_picture_resource = src_picture_resource;
50819        self
50820    }
50821    pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self {
50822        self.inner.p_setup_reference_slot = setup_reference_slot;
50823        self
50824    }
50825    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
50826        self.inner.reference_slot_count = reference_slots.len() as _;
50827        self.inner.p_reference_slots = reference_slots.as_ptr();
50828        self
50829    }
50830    pub fn preceding_externally_encoded_bytes(
50831        mut self,
50832        preceding_externally_encoded_bytes: u32,
50833    ) -> Self {
50834        self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes;
50835        self
50836    }
50837    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50838    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50839    #[doc = r" valid extension structs can be pushed into the chain."]
50840    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50841    #[doc = r" chain will look like `A -> D -> B -> C`."]
50842    pub fn push_next<T: ExtendsVideoEncodeInfoKHR>(mut self, next: &'a mut T) -> Self {
50843        unsafe {
50844            let next_ptr = <*const T>::cast(next);
50845            let last_next = ptr_chain_iter(next).last().unwrap();
50846            (*last_next).p_next = self.inner.p_next as _;
50847            self.inner.p_next = next_ptr;
50848        }
50849        self
50850    }
50851    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50852    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50853    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50854    pub fn build(self) -> VideoEncodeInfoKHR {
50855        self.inner
50856    }
50857}
50858#[repr(C)]
50859#[cfg_attr(feature = "debug", derive(Debug))]
50860#[derive(Copy, Clone)]
50861#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlInfoKHR.html>"]
50862pub struct VideoEncodeRateControlInfoKHR {
50863    pub s_type: StructureType,
50864    pub p_next: *const c_void,
50865    pub flags: VideoEncodeRateControlFlagsKHR,
50866    pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
50867    pub layer_count: u8,
50868    pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR,
50869}
50870impl ::std::default::Default for VideoEncodeRateControlInfoKHR {
50871    fn default() -> Self {
50872        Self {
50873            s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
50874            p_next: ::std::ptr::null(),
50875            flags: VideoEncodeRateControlFlagsKHR::default(),
50876            rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(),
50877            layer_count: u8::default(),
50878            p_layer_configs: ::std::ptr::null(),
50879        }
50880    }
50881}
50882impl VideoEncodeRateControlInfoKHR {
50883    pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> {
50884        VideoEncodeRateControlInfoKHRBuilder {
50885            inner: Self::default(),
50886            marker: ::std::marker::PhantomData,
50887        }
50888    }
50889}
50890#[repr(transparent)]
50891pub struct VideoEncodeRateControlInfoKHRBuilder<'a> {
50892    inner: VideoEncodeRateControlInfoKHR,
50893    marker: ::std::marker::PhantomData<&'a ()>,
50894}
50895unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHRBuilder<'_> {}
50896unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR {}
50897pub unsafe trait ExtendsVideoEncodeRateControlInfoKHR {}
50898impl<'a> ::std::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> {
50899    type Target = VideoEncodeRateControlInfoKHR;
50900    fn deref(&self) -> &Self::Target {
50901        &self.inner
50902    }
50903}
50904impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> {
50905    fn deref_mut(&mut self) -> &mut Self::Target {
50906        &mut self.inner
50907    }
50908}
50909impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
50910    pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self {
50911        self.inner.flags = flags;
50912        self
50913    }
50914    pub fn rate_control_mode(
50915        mut self,
50916        rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
50917    ) -> Self {
50918        self.inner.rate_control_mode = rate_control_mode;
50919        self
50920    }
50921    pub fn layer_configs(
50922        mut self,
50923        layer_configs: &'a [VideoEncodeRateControlLayerInfoKHR],
50924    ) -> Self {
50925        self.inner.layer_count = layer_configs.len() as _;
50926        self.inner.p_layer_configs = layer_configs.as_ptr();
50927        self
50928    }
50929    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
50930    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
50931    #[doc = r" valid extension structs can be pushed into the chain."]
50932    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
50933    #[doc = r" chain will look like `A -> D -> B -> C`."]
50934    pub fn push_next<T: ExtendsVideoEncodeRateControlInfoKHR>(mut self, next: &'a mut T) -> Self {
50935        unsafe {
50936            let next_ptr = <*const T>::cast(next);
50937            let last_next = ptr_chain_iter(next).last().unwrap();
50938            (*last_next).p_next = self.inner.p_next as _;
50939            self.inner.p_next = next_ptr;
50940        }
50941        self
50942    }
50943    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
50944    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
50945    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
50946    pub fn build(self) -> VideoEncodeRateControlInfoKHR {
50947        self.inner
50948    }
50949}
50950#[repr(C)]
50951#[cfg_attr(feature = "debug", derive(Debug))]
50952#[derive(Copy, Clone)]
50953#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlLayerInfoKHR.html>"]
50954pub struct VideoEncodeRateControlLayerInfoKHR {
50955    pub s_type: StructureType,
50956    pub p_next: *const c_void,
50957    pub average_bitrate: u32,
50958    pub max_bitrate: u32,
50959    pub frame_rate_numerator: u32,
50960    pub frame_rate_denominator: u32,
50961    pub virtual_buffer_size_in_ms: u32,
50962    pub initial_virtual_buffer_size_in_ms: u32,
50963}
50964impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR {
50965    fn default() -> Self {
50966        Self {
50967            s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR,
50968            p_next: ::std::ptr::null(),
50969            average_bitrate: u32::default(),
50970            max_bitrate: u32::default(),
50971            frame_rate_numerator: u32::default(),
50972            frame_rate_denominator: u32::default(),
50973            virtual_buffer_size_in_ms: u32::default(),
50974            initial_virtual_buffer_size_in_ms: u32::default(),
50975        }
50976    }
50977}
50978impl VideoEncodeRateControlLayerInfoKHR {
50979    pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
50980        VideoEncodeRateControlLayerInfoKHRBuilder {
50981            inner: Self::default(),
50982            marker: ::std::marker::PhantomData,
50983        }
50984    }
50985}
50986#[repr(transparent)]
50987pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
50988    inner: VideoEncodeRateControlLayerInfoKHR,
50989    marker: ::std::marker::PhantomData<&'a ()>,
50990}
50991unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {}
50992unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {}
50993pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {}
50994impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
50995    type Target = VideoEncodeRateControlLayerInfoKHR;
50996    fn deref(&self) -> &Self::Target {
50997        &self.inner
50998    }
50999}
51000impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
51001    fn deref_mut(&mut self) -> &mut Self::Target {
51002        &mut self.inner
51003    }
51004}
51005impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
51006    pub fn average_bitrate(mut self, average_bitrate: u32) -> Self {
51007        self.inner.average_bitrate = average_bitrate;
51008        self
51009    }
51010    pub fn max_bitrate(mut self, max_bitrate: u32) -> Self {
51011        self.inner.max_bitrate = max_bitrate;
51012        self
51013    }
51014    pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self {
51015        self.inner.frame_rate_numerator = frame_rate_numerator;
51016        self
51017    }
51018    pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self {
51019        self.inner.frame_rate_denominator = frame_rate_denominator;
51020        self
51021    }
51022    pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self {
51023        self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms;
51024        self
51025    }
51026    pub fn initial_virtual_buffer_size_in_ms(
51027        mut self,
51028        initial_virtual_buffer_size_in_ms: u32,
51029    ) -> Self {
51030        self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms;
51031        self
51032    }
51033    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
51034    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
51035    #[doc = r" valid extension structs can be pushed into the chain."]
51036    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
51037    #[doc = r" chain will look like `A -> D -> B -> C`."]
51038    pub fn push_next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>(
51039        mut self,
51040        next: &'a mut T,
51041    ) -> Self {
51042        unsafe {
51043            let next_ptr = <*const T>::cast(next);
51044            let last_next = ptr_chain_iter(next).last().unwrap();
51045            (*last_next).p_next = self.inner.p_next as _;
51046            self.inner.p_next = next_ptr;
51047        }
51048        self
51049    }
51050    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51051    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51052    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51053    pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR {
51054        self.inner
51055    }
51056}
51057#[repr(C)]
51058#[cfg_attr(feature = "debug", derive(Debug))]
51059#[derive(Copy, Clone)]
51060#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeCapabilitiesKHR.html>"]
51061pub struct VideoEncodeCapabilitiesKHR {
51062    pub s_type: StructureType,
51063    pub p_next: *const c_void,
51064    pub flags: VideoEncodeCapabilityFlagsKHR,
51065    pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
51066    pub rate_control_layer_count: u8,
51067    pub quality_level_count: u8,
51068    pub input_image_data_fill_alignment: Extent2D,
51069}
51070impl ::std::default::Default for VideoEncodeCapabilitiesKHR {
51071    fn default() -> Self {
51072        Self {
51073            s_type: StructureType::VIDEO_ENCODE_CAPABILITIES_KHR,
51074            p_next: ::std::ptr::null(),
51075            flags: VideoEncodeCapabilityFlagsKHR::default(),
51076            rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(),
51077            rate_control_layer_count: u8::default(),
51078            quality_level_count: u8::default(),
51079            input_image_data_fill_alignment: Extent2D::default(),
51080        }
51081    }
51082}
51083impl VideoEncodeCapabilitiesKHR {
51084    pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> {
51085        VideoEncodeCapabilitiesKHRBuilder {
51086            inner: Self::default(),
51087            marker: ::std::marker::PhantomData,
51088        }
51089    }
51090}
51091#[repr(transparent)]
51092pub struct VideoEncodeCapabilitiesKHRBuilder<'a> {
51093    inner: VideoEncodeCapabilitiesKHR,
51094    marker: ::std::marker::PhantomData<&'a ()>,
51095}
51096unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHRBuilder<'_> {}
51097unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR {}
51098pub unsafe trait ExtendsVideoEncodeCapabilitiesKHR {}
51099impl<'a> ::std::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> {
51100    type Target = VideoEncodeCapabilitiesKHR;
51101    fn deref(&self) -> &Self::Target {
51102        &self.inner
51103    }
51104}
51105impl<'a> ::std::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> {
51106    fn deref_mut(&mut self) -> &mut Self::Target {
51107        &mut self.inner
51108    }
51109}
51110impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> {
51111    pub fn flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self {
51112        self.inner.flags = flags;
51113        self
51114    }
51115    pub fn rate_control_modes(
51116        mut self,
51117        rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
51118    ) -> Self {
51119        self.inner.rate_control_modes = rate_control_modes;
51120        self
51121    }
51122    pub fn rate_control_layer_count(mut self, rate_control_layer_count: u8) -> Self {
51123        self.inner.rate_control_layer_count = rate_control_layer_count;
51124        self
51125    }
51126    pub fn quality_level_count(mut self, quality_level_count: u8) -> Self {
51127        self.inner.quality_level_count = quality_level_count;
51128        self
51129    }
51130    pub fn input_image_data_fill_alignment(
51131        mut self,
51132        input_image_data_fill_alignment: Extent2D,
51133    ) -> Self {
51134        self.inner.input_image_data_fill_alignment = input_image_data_fill_alignment;
51135        self
51136    }
51137    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
51138    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
51139    #[doc = r" valid extension structs can be pushed into the chain."]
51140    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
51141    #[doc = r" chain will look like `A -> D -> B -> C`."]
51142    pub fn push_next<T: ExtendsVideoEncodeCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
51143        unsafe {
51144            let next_ptr = <*const T>::cast(next);
51145            let last_next = ptr_chain_iter(next).last().unwrap();
51146            (*last_next).p_next = self.inner.p_next as _;
51147            self.inner.p_next = next_ptr;
51148        }
51149        self
51150    }
51151    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51152    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51153    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51154    pub fn build(self) -> VideoEncodeCapabilitiesKHR {
51155        self.inner
51156    }
51157}
51158#[repr(C)]
51159#[cfg_attr(feature = "debug", derive(Debug))]
51160#[derive(Copy, Clone)]
51161#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264CapabilitiesEXT.html>"]
51162pub struct VideoEncodeH264CapabilitiesEXT {
51163    pub s_type: StructureType,
51164    pub p_next: *const c_void,
51165    pub flags: VideoEncodeH264CapabilityFlagsEXT,
51166    pub input_mode_flags: VideoEncodeH264InputModeFlagsEXT,
51167    pub output_mode_flags: VideoEncodeH264OutputModeFlagsEXT,
51168    pub max_p_picture_l0_reference_count: u8,
51169    pub max_b_picture_l0_reference_count: u8,
51170    pub max_l1_reference_count: u8,
51171    pub motion_vectors_over_pic_boundaries_flag: Bool32,
51172    pub max_bytes_per_pic_denom: u32,
51173    pub max_bits_per_mb_denom: u32,
51174    pub log2_max_mv_length_horizontal: u32,
51175    pub log2_max_mv_length_vertical: u32,
51176}
51177impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT {
51178    fn default() -> Self {
51179        Self {
51180            s_type: StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT,
51181            p_next: ::std::ptr::null(),
51182            flags: VideoEncodeH264CapabilityFlagsEXT::default(),
51183            input_mode_flags: VideoEncodeH264InputModeFlagsEXT::default(),
51184            output_mode_flags: VideoEncodeH264OutputModeFlagsEXT::default(),
51185            max_p_picture_l0_reference_count: u8::default(),
51186            max_b_picture_l0_reference_count: u8::default(),
51187            max_l1_reference_count: u8::default(),
51188            motion_vectors_over_pic_boundaries_flag: Bool32::default(),
51189            max_bytes_per_pic_denom: u32::default(),
51190            max_bits_per_mb_denom: u32::default(),
51191            log2_max_mv_length_horizontal: u32::default(),
51192            log2_max_mv_length_vertical: u32::default(),
51193        }
51194    }
51195}
51196impl VideoEncodeH264CapabilitiesEXT {
51197    pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51198        VideoEncodeH264CapabilitiesEXTBuilder {
51199            inner: Self::default(),
51200            marker: ::std::marker::PhantomData,
51201        }
51202    }
51203}
51204#[repr(transparent)]
51205pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51206    inner: VideoEncodeH264CapabilitiesEXT,
51207    marker: ::std::marker::PhantomData<&'a ()>,
51208}
51209unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {}
51210unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {}
51211impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51212    type Target = VideoEncodeH264CapabilitiesEXT;
51213    fn deref(&self) -> &Self::Target {
51214        &self.inner
51215    }
51216}
51217impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51218    fn deref_mut(&mut self) -> &mut Self::Target {
51219        &mut self.inner
51220    }
51221}
51222impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
51223    pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self {
51224        self.inner.flags = flags;
51225        self
51226    }
51227    pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH264InputModeFlagsEXT) -> Self {
51228        self.inner.input_mode_flags = input_mode_flags;
51229        self
51230    }
51231    pub fn output_mode_flags(
51232        mut self,
51233        output_mode_flags: VideoEncodeH264OutputModeFlagsEXT,
51234    ) -> Self {
51235        self.inner.output_mode_flags = output_mode_flags;
51236        self
51237    }
51238    pub fn max_p_picture_l0_reference_count(
51239        mut self,
51240        max_p_picture_l0_reference_count: u8,
51241    ) -> Self {
51242        self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
51243        self
51244    }
51245    pub fn max_b_picture_l0_reference_count(
51246        mut self,
51247        max_b_picture_l0_reference_count: u8,
51248    ) -> Self {
51249        self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
51250        self
51251    }
51252    pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self {
51253        self.inner.max_l1_reference_count = max_l1_reference_count;
51254        self
51255    }
51256    pub fn motion_vectors_over_pic_boundaries_flag(
51257        mut self,
51258        motion_vectors_over_pic_boundaries_flag: bool,
51259    ) -> Self {
51260        self.inner.motion_vectors_over_pic_boundaries_flag =
51261            motion_vectors_over_pic_boundaries_flag.into();
51262        self
51263    }
51264    pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self {
51265        self.inner.max_bytes_per_pic_denom = max_bytes_per_pic_denom;
51266        self
51267    }
51268    pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self {
51269        self.inner.max_bits_per_mb_denom = max_bits_per_mb_denom;
51270        self
51271    }
51272    pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self {
51273        self.inner.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal;
51274        self
51275    }
51276    pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self {
51277        self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical;
51278        self
51279    }
51280    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51281    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51282    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51283    pub fn build(self) -> VideoEncodeH264CapabilitiesEXT {
51284        self.inner
51285    }
51286}
51287#[repr(C)]
51288#[cfg_attr(feature = "debug", derive(Debug))]
51289#[derive(Copy, Clone)]
51290#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264SessionParametersAddInfoEXT.html>"]
51291pub struct VideoEncodeH264SessionParametersAddInfoEXT {
51292    pub s_type: StructureType,
51293    pub p_next: *const c_void,
51294    pub sps_std_count: u32,
51295    pub p_sps_std: *const StdVideoH264SequenceParameterSet,
51296    pub pps_std_count: u32,
51297    pub p_pps_std: *const StdVideoH264PictureParameterSet,
51298}
51299impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT {
51300    fn default() -> Self {
51301        Self {
51302            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT,
51303            p_next: ::std::ptr::null(),
51304            sps_std_count: u32::default(),
51305            p_sps_std: ::std::ptr::null(),
51306            pps_std_count: u32::default(),
51307            p_pps_std: ::std::ptr::null(),
51308        }
51309    }
51310}
51311impl VideoEncodeH264SessionParametersAddInfoEXT {
51312    pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51313        VideoEncodeH264SessionParametersAddInfoEXTBuilder {
51314            inner: Self::default(),
51315            marker: ::std::marker::PhantomData,
51316        }
51317    }
51318}
51319#[repr(transparent)]
51320pub struct VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51321    inner: VideoEncodeH264SessionParametersAddInfoEXT,
51322    marker: ::std::marker::PhantomData<&'a ()>,
51323}
51324unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
51325    for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'_>
51326{
51327}
51328unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
51329    for VideoEncodeH264SessionParametersAddInfoEXT
51330{
51331}
51332impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51333    type Target = VideoEncodeH264SessionParametersAddInfoEXT;
51334    fn deref(&self) -> &Self::Target {
51335        &self.inner
51336    }
51337}
51338impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51339    fn deref_mut(&mut self) -> &mut Self::Target {
51340        &mut self.inner
51341    }
51342}
51343impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
51344    pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self {
51345        self.inner.sps_std_count = sps_std.len() as _;
51346        self.inner.p_sps_std = sps_std.as_ptr();
51347        self
51348    }
51349    pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self {
51350        self.inner.pps_std_count = pps_std.len() as _;
51351        self.inner.p_pps_std = pps_std.as_ptr();
51352        self
51353    }
51354    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51355    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51356    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51357    pub fn build(self) -> VideoEncodeH264SessionParametersAddInfoEXT {
51358        self.inner
51359    }
51360}
51361#[repr(C)]
51362#[cfg_attr(feature = "debug", derive(Debug))]
51363#[derive(Copy, Clone)]
51364#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264SessionParametersCreateInfoEXT.html>"]
51365pub struct VideoEncodeH264SessionParametersCreateInfoEXT {
51366    pub s_type: StructureType,
51367    pub p_next: *const c_void,
51368    pub max_sps_std_count: u32,
51369    pub max_pps_std_count: u32,
51370    pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT,
51371}
51372impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT {
51373    fn default() -> Self {
51374        Self {
51375            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT,
51376            p_next: ::std::ptr::null(),
51377            max_sps_std_count: u32::default(),
51378            max_pps_std_count: u32::default(),
51379            p_parameters_add_info: ::std::ptr::null(),
51380        }
51381    }
51382}
51383impl VideoEncodeH264SessionParametersCreateInfoEXT {
51384    pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51385        VideoEncodeH264SessionParametersCreateInfoEXTBuilder {
51386            inner: Self::default(),
51387            marker: ::std::marker::PhantomData,
51388        }
51389    }
51390}
51391#[repr(transparent)]
51392pub struct VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51393    inner: VideoEncodeH264SessionParametersCreateInfoEXT,
51394    marker: ::std::marker::PhantomData<&'a ()>,
51395}
51396unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
51397    for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'_>
51398{
51399}
51400unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
51401    for VideoEncodeH264SessionParametersCreateInfoEXT
51402{
51403}
51404impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51405    type Target = VideoEncodeH264SessionParametersCreateInfoEXT;
51406    fn deref(&self) -> &Self::Target {
51407        &self.inner
51408    }
51409}
51410impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51411    fn deref_mut(&mut self) -> &mut Self::Target {
51412        &mut self.inner
51413    }
51414}
51415impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
51416    pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
51417        self.inner.max_sps_std_count = max_sps_std_count;
51418        self
51419    }
51420    pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
51421        self.inner.max_pps_std_count = max_pps_std_count;
51422        self
51423    }
51424    pub fn parameters_add_info(
51425        mut self,
51426        parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT,
51427    ) -> Self {
51428        self.inner.p_parameters_add_info = parameters_add_info;
51429        self
51430    }
51431    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51432    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51433    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51434    pub fn build(self) -> VideoEncodeH264SessionParametersCreateInfoEXT {
51435        self.inner
51436    }
51437}
51438#[repr(C)]
51439#[cfg_attr(feature = "debug", derive(Debug))]
51440#[derive(Copy, Clone)]
51441#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264DpbSlotInfoEXT.html>"]
51442pub struct VideoEncodeH264DpbSlotInfoEXT {
51443    pub s_type: StructureType,
51444    pub p_next: *const c_void,
51445    pub slot_index: i8,
51446    pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo,
51447}
51448impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT {
51449    fn default() -> Self {
51450        Self {
51451            s_type: StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT,
51452            p_next: ::std::ptr::null(),
51453            slot_index: i8::default(),
51454            p_std_reference_info: ::std::ptr::null(),
51455        }
51456    }
51457}
51458impl VideoEncodeH264DpbSlotInfoEXT {
51459    pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51460        VideoEncodeH264DpbSlotInfoEXTBuilder {
51461            inner: Self::default(),
51462            marker: ::std::marker::PhantomData,
51463        }
51464    }
51465}
51466#[repr(transparent)]
51467pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51468    inner: VideoEncodeH264DpbSlotInfoEXT,
51469    marker: ::std::marker::PhantomData<&'a ()>,
51470}
51471impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51472    type Target = VideoEncodeH264DpbSlotInfoEXT;
51473    fn deref(&self) -> &Self::Target {
51474        &self.inner
51475    }
51476}
51477impl<'a> ::std::ops::DerefMut for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51478    fn deref_mut(&mut self) -> &mut Self::Target {
51479        &mut self.inner
51480    }
51481}
51482impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
51483    pub fn slot_index(mut self, slot_index: i8) -> Self {
51484        self.inner.slot_index = slot_index;
51485        self
51486    }
51487    pub fn std_reference_info(
51488        mut self,
51489        std_reference_info: &'a StdVideoEncodeH264ReferenceInfo,
51490    ) -> Self {
51491        self.inner.p_std_reference_info = std_reference_info;
51492        self
51493    }
51494    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51495    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51496    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51497    pub fn build(self) -> VideoEncodeH264DpbSlotInfoEXT {
51498        self.inner
51499    }
51500}
51501#[repr(C)]
51502#[cfg_attr(feature = "debug", derive(Debug))]
51503#[derive(Copy, Clone)]
51504#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264VclFrameInfoEXT.html>"]
51505pub struct VideoEncodeH264VclFrameInfoEXT {
51506    pub s_type: StructureType,
51507    pub p_next: *const c_void,
51508    pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT,
51509    pub nalu_slice_entry_count: u32,
51510    pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceEXT,
51511    pub p_current_picture_info: *const StdVideoEncodeH264PictureInfo,
51512}
51513impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT {
51514    fn default() -> Self {
51515        Self {
51516            s_type: StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT,
51517            p_next: ::std::ptr::null(),
51518            p_reference_final_lists: ::std::ptr::null(),
51519            nalu_slice_entry_count: u32::default(),
51520            p_nalu_slice_entries: ::std::ptr::null(),
51521            p_current_picture_info: ::std::ptr::null(),
51522        }
51523    }
51524}
51525impl VideoEncodeH264VclFrameInfoEXT {
51526    pub fn builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51527        VideoEncodeH264VclFrameInfoEXTBuilder {
51528            inner: Self::default(),
51529            marker: ::std::marker::PhantomData,
51530        }
51531    }
51532}
51533#[repr(transparent)]
51534pub struct VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51535    inner: VideoEncodeH264VclFrameInfoEXT,
51536    marker: ::std::marker::PhantomData<&'a ()>,
51537}
51538unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXTBuilder<'_> {}
51539unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT {}
51540impl<'a> ::std::ops::Deref for VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51541    type Target = VideoEncodeH264VclFrameInfoEXT;
51542    fn deref(&self) -> &Self::Target {
51543        &self.inner
51544    }
51545}
51546impl<'a> ::std::ops::DerefMut for VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51547    fn deref_mut(&mut self) -> &mut Self::Target {
51548        &mut self.inner
51549    }
51550}
51551impl<'a> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
51552    pub fn reference_final_lists(
51553        mut self,
51554        reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT,
51555    ) -> Self {
51556        self.inner.p_reference_final_lists = reference_final_lists;
51557        self
51558    }
51559    pub fn nalu_slice_entries(
51560        mut self,
51561        nalu_slice_entries: &'a [VideoEncodeH264NaluSliceEXT],
51562    ) -> Self {
51563        self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _;
51564        self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr();
51565        self
51566    }
51567    pub fn current_picture_info(
51568        mut self,
51569        current_picture_info: &'a StdVideoEncodeH264PictureInfo,
51570    ) -> Self {
51571        self.inner.p_current_picture_info = current_picture_info;
51572        self
51573    }
51574    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51575    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51576    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51577    pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT {
51578        self.inner
51579    }
51580}
51581#[repr(C)]
51582#[cfg_attr(feature = "debug", derive(Debug))]
51583#[derive(Copy, Clone)]
51584#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264ReferenceListsEXT.html>"]
51585pub struct VideoEncodeH264ReferenceListsEXT {
51586    pub s_type: StructureType,
51587    pub p_next: *const c_void,
51588    pub reference_list0_entry_count: u8,
51589    pub p_reference_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT,
51590    pub reference_list1_entry_count: u8,
51591    pub p_reference_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT,
51592    pub p_mem_mgmt_ctrl_operations: *const StdVideoEncodeH264RefMemMgmtCtrlOperations,
51593}
51594impl ::std::default::Default for VideoEncodeH264ReferenceListsEXT {
51595    fn default() -> Self {
51596        Self {
51597            s_type: StructureType::VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT,
51598            p_next: ::std::ptr::null(),
51599            reference_list0_entry_count: u8::default(),
51600            p_reference_list0_entries: ::std::ptr::null(),
51601            reference_list1_entry_count: u8::default(),
51602            p_reference_list1_entries: ::std::ptr::null(),
51603            p_mem_mgmt_ctrl_operations: ::std::ptr::null(),
51604        }
51605    }
51606}
51607impl VideoEncodeH264ReferenceListsEXT {
51608    pub fn builder<'a>() -> VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51609        VideoEncodeH264ReferenceListsEXTBuilder {
51610            inner: Self::default(),
51611            marker: ::std::marker::PhantomData,
51612        }
51613    }
51614}
51615#[repr(transparent)]
51616pub struct VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51617    inner: VideoEncodeH264ReferenceListsEXT,
51618    marker: ::std::marker::PhantomData<&'a ()>,
51619}
51620impl<'a> ::std::ops::Deref for VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51621    type Target = VideoEncodeH264ReferenceListsEXT;
51622    fn deref(&self) -> &Self::Target {
51623        &self.inner
51624    }
51625}
51626impl<'a> ::std::ops::DerefMut for VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51627    fn deref_mut(&mut self) -> &mut Self::Target {
51628        &mut self.inner
51629    }
51630}
51631impl<'a> VideoEncodeH264ReferenceListsEXTBuilder<'a> {
51632    pub fn reference_list0_entries(
51633        mut self,
51634        reference_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
51635    ) -> Self {
51636        self.inner.reference_list0_entry_count = reference_list0_entries.len() as _;
51637        self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr();
51638        self
51639    }
51640    pub fn reference_list1_entries(
51641        mut self,
51642        reference_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
51643    ) -> Self {
51644        self.inner.reference_list1_entry_count = reference_list1_entries.len() as _;
51645        self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr();
51646        self
51647    }
51648    pub fn mem_mgmt_ctrl_operations(
51649        mut self,
51650        mem_mgmt_ctrl_operations: &'a StdVideoEncodeH264RefMemMgmtCtrlOperations,
51651    ) -> Self {
51652        self.inner.p_mem_mgmt_ctrl_operations = mem_mgmt_ctrl_operations;
51653        self
51654    }
51655    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51656    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51657    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51658    pub fn build(self) -> VideoEncodeH264ReferenceListsEXT {
51659        self.inner
51660    }
51661}
51662#[repr(C)]
51663#[cfg_attr(feature = "debug", derive(Debug))]
51664#[derive(Copy, Clone)]
51665#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264EmitPictureParametersEXT.html>"]
51666pub struct VideoEncodeH264EmitPictureParametersEXT {
51667    pub s_type: StructureType,
51668    pub p_next: *const c_void,
51669    pub sps_id: u8,
51670    pub emit_sps_enable: Bool32,
51671    pub pps_id_entry_count: u32,
51672    pub pps_id_entries: *const u8,
51673}
51674impl ::std::default::Default for VideoEncodeH264EmitPictureParametersEXT {
51675    fn default() -> Self {
51676        Self {
51677            s_type: StructureType::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT,
51678            p_next: ::std::ptr::null(),
51679            sps_id: u8::default(),
51680            emit_sps_enable: Bool32::default(),
51681            pps_id_entry_count: u32::default(),
51682            pps_id_entries: ::std::ptr::null(),
51683        }
51684    }
51685}
51686impl VideoEncodeH264EmitPictureParametersEXT {
51687    pub fn builder<'a>() -> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51688        VideoEncodeH264EmitPictureParametersEXTBuilder {
51689            inner: Self::default(),
51690            marker: ::std::marker::PhantomData,
51691        }
51692    }
51693}
51694#[repr(transparent)]
51695pub struct VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51696    inner: VideoEncodeH264EmitPictureParametersEXT,
51697    marker: ::std::marker::PhantomData<&'a ()>,
51698}
51699unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXTBuilder<'_> {}
51700unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXT {}
51701impl<'a> ::std::ops::Deref for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51702    type Target = VideoEncodeH264EmitPictureParametersEXT;
51703    fn deref(&self) -> &Self::Target {
51704        &self.inner
51705    }
51706}
51707impl<'a> ::std::ops::DerefMut for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51708    fn deref_mut(&mut self) -> &mut Self::Target {
51709        &mut self.inner
51710    }
51711}
51712impl<'a> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
51713    pub fn sps_id(mut self, sps_id: u8) -> Self {
51714        self.inner.sps_id = sps_id;
51715        self
51716    }
51717    pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self {
51718        self.inner.emit_sps_enable = emit_sps_enable.into();
51719        self
51720    }
51721    pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self {
51722        self.inner.pps_id_entry_count = pps_id_entries.len() as _;
51723        self.inner.pps_id_entries = pps_id_entries.as_ptr();
51724        self
51725    }
51726    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51727    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51728    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51729    pub fn build(self) -> VideoEncodeH264EmitPictureParametersEXT {
51730        self.inner
51731    }
51732}
51733#[repr(C)]
51734#[cfg_attr(feature = "debug", derive(Debug))]
51735#[derive(Copy, Clone)]
51736#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264ProfileEXT.html>"]
51737pub struct VideoEncodeH264ProfileEXT {
51738    pub s_type: StructureType,
51739    pub p_next: *const c_void,
51740    pub std_profile_idc: StdVideoH264ProfileIdc,
51741}
51742impl ::std::default::Default for VideoEncodeH264ProfileEXT {
51743    fn default() -> Self {
51744        Self {
51745            s_type: StructureType::VIDEO_ENCODE_H264_PROFILE_EXT,
51746            p_next: ::std::ptr::null(),
51747            std_profile_idc: StdVideoH264ProfileIdc::default(),
51748        }
51749    }
51750}
51751impl VideoEncodeH264ProfileEXT {
51752    pub fn builder<'a>() -> VideoEncodeH264ProfileEXTBuilder<'a> {
51753        VideoEncodeH264ProfileEXTBuilder {
51754            inner: Self::default(),
51755            marker: ::std::marker::PhantomData,
51756        }
51757    }
51758}
51759#[repr(transparent)]
51760pub struct VideoEncodeH264ProfileEXTBuilder<'a> {
51761    inner: VideoEncodeH264ProfileEXT,
51762    marker: ::std::marker::PhantomData<&'a ()>,
51763}
51764unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXTBuilder<'_> {}
51765unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT {}
51766unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51767unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXT {}
51768unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXTBuilder<'_> {}
51769unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXT {}
51770unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51771unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXT {}
51772unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51773unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXT {}
51774unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {}
51775unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXT {}
51776impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileEXTBuilder<'a> {
51777    type Target = VideoEncodeH264ProfileEXT;
51778    fn deref(&self) -> &Self::Target {
51779        &self.inner
51780    }
51781}
51782impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileEXTBuilder<'a> {
51783    fn deref_mut(&mut self) -> &mut Self::Target {
51784        &mut self.inner
51785    }
51786}
51787impl<'a> VideoEncodeH264ProfileEXTBuilder<'a> {
51788    pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
51789        self.inner.std_profile_idc = std_profile_idc;
51790        self
51791    }
51792    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51793    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51794    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51795    pub fn build(self) -> VideoEncodeH264ProfileEXT {
51796        self.inner
51797    }
51798}
51799#[repr(C)]
51800#[cfg_attr(feature = "debug", derive(Debug))]
51801#[derive(Copy, Clone)]
51802#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264NaluSliceEXT.html>"]
51803pub struct VideoEncodeH264NaluSliceEXT {
51804    pub s_type: StructureType,
51805    pub p_next: *const c_void,
51806    pub mb_count: u32,
51807    pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT,
51808    pub p_slice_header_std: *const StdVideoEncodeH264SliceHeader,
51809}
51810impl ::std::default::Default for VideoEncodeH264NaluSliceEXT {
51811    fn default() -> Self {
51812        Self {
51813            s_type: StructureType::VIDEO_ENCODE_H264_NALU_SLICE_EXT,
51814            p_next: ::std::ptr::null(),
51815            mb_count: u32::default(),
51816            p_reference_final_lists: ::std::ptr::null(),
51817            p_slice_header_std: ::std::ptr::null(),
51818        }
51819    }
51820}
51821impl VideoEncodeH264NaluSliceEXT {
51822    pub fn builder<'a>() -> VideoEncodeH264NaluSliceEXTBuilder<'a> {
51823        VideoEncodeH264NaluSliceEXTBuilder {
51824            inner: Self::default(),
51825            marker: ::std::marker::PhantomData,
51826        }
51827    }
51828}
51829#[repr(transparent)]
51830pub struct VideoEncodeH264NaluSliceEXTBuilder<'a> {
51831    inner: VideoEncodeH264NaluSliceEXT,
51832    marker: ::std::marker::PhantomData<&'a ()>,
51833}
51834impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceEXTBuilder<'a> {
51835    type Target = VideoEncodeH264NaluSliceEXT;
51836    fn deref(&self) -> &Self::Target {
51837        &self.inner
51838    }
51839}
51840impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceEXTBuilder<'a> {
51841    fn deref_mut(&mut self) -> &mut Self::Target {
51842        &mut self.inner
51843    }
51844}
51845impl<'a> VideoEncodeH264NaluSliceEXTBuilder<'a> {
51846    pub fn mb_count(mut self, mb_count: u32) -> Self {
51847        self.inner.mb_count = mb_count;
51848        self
51849    }
51850    pub fn reference_final_lists(
51851        mut self,
51852        reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT,
51853    ) -> Self {
51854        self.inner.p_reference_final_lists = reference_final_lists;
51855        self
51856    }
51857    pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH264SliceHeader) -> Self {
51858        self.inner.p_slice_header_std = slice_header_std;
51859        self
51860    }
51861    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51862    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51863    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51864    pub fn build(self) -> VideoEncodeH264NaluSliceEXT {
51865        self.inner
51866    }
51867}
51868#[repr(C)]
51869#[cfg_attr(feature = "debug", derive(Debug))]
51870#[derive(Copy, Clone)]
51871#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlInfoEXT.html>"]
51872pub struct VideoEncodeH264RateControlInfoEXT {
51873    pub s_type: StructureType,
51874    pub p_next: *const c_void,
51875    pub gop_frame_count: u32,
51876    pub idr_period: u32,
51877    pub consecutive_b_frame_count: u32,
51878    pub rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT,
51879    pub temporal_layer_count: u8,
51880}
51881impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT {
51882    fn default() -> Self {
51883        Self {
51884            s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT,
51885            p_next: ::std::ptr::null(),
51886            gop_frame_count: u32::default(),
51887            idr_period: u32::default(),
51888            consecutive_b_frame_count: u32::default(),
51889            rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT::default(),
51890            temporal_layer_count: u8::default(),
51891        }
51892    }
51893}
51894impl VideoEncodeH264RateControlInfoEXT {
51895    pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51896        VideoEncodeH264RateControlInfoEXTBuilder {
51897            inner: Self::default(),
51898            marker: ::std::marker::PhantomData,
51899        }
51900    }
51901}
51902#[repr(transparent)]
51903pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51904    inner: VideoEncodeH264RateControlInfoEXT,
51905    marker: ::std::marker::PhantomData<&'a ()>,
51906}
51907unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {}
51908unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXT {}
51909impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51910    type Target = VideoEncodeH264RateControlInfoEXT;
51911    fn deref(&self) -> &Self::Target {
51912        &self.inner
51913    }
51914}
51915impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51916    fn deref_mut(&mut self) -> &mut Self::Target {
51917        &mut self.inner
51918    }
51919}
51920impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
51921    pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
51922        self.inner.gop_frame_count = gop_frame_count;
51923        self
51924    }
51925    pub fn idr_period(mut self, idr_period: u32) -> Self {
51926        self.inner.idr_period = idr_period;
51927        self
51928    }
51929    pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
51930        self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
51931        self
51932    }
51933    pub fn rate_control_structure(
51934        mut self,
51935        rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT,
51936    ) -> Self {
51937        self.inner.rate_control_structure = rate_control_structure;
51938        self
51939    }
51940    pub fn temporal_layer_count(mut self, temporal_layer_count: u8) -> Self {
51941        self.inner.temporal_layer_count = temporal_layer_count;
51942        self
51943    }
51944    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51945    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51946    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
51947    pub fn build(self) -> VideoEncodeH264RateControlInfoEXT {
51948        self.inner
51949    }
51950}
51951#[repr(C)]
51952#[cfg_attr(feature = "debug", derive(Debug))]
51953#[derive(Copy, Clone, Default)]
51954#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264QpEXT.html>"]
51955pub struct VideoEncodeH264QpEXT {
51956    pub qp_i: i32,
51957    pub qp_p: i32,
51958    pub qp_b: i32,
51959}
51960impl VideoEncodeH264QpEXT {
51961    pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> {
51962        VideoEncodeH264QpEXTBuilder {
51963            inner: Self::default(),
51964            marker: ::std::marker::PhantomData,
51965        }
51966    }
51967}
51968#[repr(transparent)]
51969pub struct VideoEncodeH264QpEXTBuilder<'a> {
51970    inner: VideoEncodeH264QpEXT,
51971    marker: ::std::marker::PhantomData<&'a ()>,
51972}
51973impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> {
51974    type Target = VideoEncodeH264QpEXT;
51975    fn deref(&self) -> &Self::Target {
51976        &self.inner
51977    }
51978}
51979impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> {
51980    fn deref_mut(&mut self) -> &mut Self::Target {
51981        &mut self.inner
51982    }
51983}
51984impl<'a> VideoEncodeH264QpEXTBuilder<'a> {
51985    pub fn qp_i(mut self, qp_i: i32) -> Self {
51986        self.inner.qp_i = qp_i;
51987        self
51988    }
51989    pub fn qp_p(mut self, qp_p: i32) -> Self {
51990        self.inner.qp_p = qp_p;
51991        self
51992    }
51993    pub fn qp_b(mut self, qp_b: i32) -> Self {
51994        self.inner.qp_b = qp_b;
51995        self
51996    }
51997    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
51998    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
51999    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52000    pub fn build(self) -> VideoEncodeH264QpEXT {
52001        self.inner
52002    }
52003}
52004#[repr(C)]
52005#[cfg_attr(feature = "debug", derive(Debug))]
52006#[derive(Copy, Clone, Default)]
52007#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264FrameSizeEXT.html>"]
52008pub struct VideoEncodeH264FrameSizeEXT {
52009    pub frame_i_size: u32,
52010    pub frame_p_size: u32,
52011    pub frame_b_size: u32,
52012}
52013impl VideoEncodeH264FrameSizeEXT {
52014    pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> {
52015        VideoEncodeH264FrameSizeEXTBuilder {
52016            inner: Self::default(),
52017            marker: ::std::marker::PhantomData,
52018        }
52019    }
52020}
52021#[repr(transparent)]
52022pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> {
52023    inner: VideoEncodeH264FrameSizeEXT,
52024    marker: ::std::marker::PhantomData<&'a ()>,
52025}
52026impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> {
52027    type Target = VideoEncodeH264FrameSizeEXT;
52028    fn deref(&self) -> &Self::Target {
52029        &self.inner
52030    }
52031}
52032impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> {
52033    fn deref_mut(&mut self) -> &mut Self::Target {
52034        &mut self.inner
52035    }
52036}
52037impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> {
52038    pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
52039        self.inner.frame_i_size = frame_i_size;
52040        self
52041    }
52042    pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
52043        self.inner.frame_p_size = frame_p_size;
52044        self
52045    }
52046    pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
52047        self.inner.frame_b_size = frame_b_size;
52048        self
52049    }
52050    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52051    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52052    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52053    pub fn build(self) -> VideoEncodeH264FrameSizeEXT {
52054        self.inner
52055    }
52056}
52057#[repr(C)]
52058#[cfg_attr(feature = "debug", derive(Debug))]
52059#[derive(Copy, Clone)]
52060#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlLayerInfoEXT.html>"]
52061pub struct VideoEncodeH264RateControlLayerInfoEXT {
52062    pub s_type: StructureType,
52063    pub p_next: *const c_void,
52064    pub temporal_layer_id: u8,
52065    pub use_initial_rc_qp: Bool32,
52066    pub initial_rc_qp: VideoEncodeH264QpEXT,
52067    pub use_min_qp: Bool32,
52068    pub min_qp: VideoEncodeH264QpEXT,
52069    pub use_max_qp: Bool32,
52070    pub max_qp: VideoEncodeH264QpEXT,
52071    pub use_max_frame_size: Bool32,
52072    pub max_frame_size: VideoEncodeH264FrameSizeEXT,
52073}
52074impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT {
52075    fn default() -> Self {
52076        Self {
52077            s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT,
52078            p_next: ::std::ptr::null(),
52079            temporal_layer_id: u8::default(),
52080            use_initial_rc_qp: Bool32::default(),
52081            initial_rc_qp: VideoEncodeH264QpEXT::default(),
52082            use_min_qp: Bool32::default(),
52083            min_qp: VideoEncodeH264QpEXT::default(),
52084            use_max_qp: Bool32::default(),
52085            max_qp: VideoEncodeH264QpEXT::default(),
52086            use_max_frame_size: Bool32::default(),
52087            max_frame_size: VideoEncodeH264FrameSizeEXT::default(),
52088        }
52089    }
52090}
52091impl VideoEncodeH264RateControlLayerInfoEXT {
52092    pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52093        VideoEncodeH264RateControlLayerInfoEXTBuilder {
52094            inner: Self::default(),
52095            marker: ::std::marker::PhantomData,
52096        }
52097    }
52098}
52099#[repr(transparent)]
52100pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52101    inner: VideoEncodeH264RateControlLayerInfoEXT,
52102    marker: ::std::marker::PhantomData<&'a ()>,
52103}
52104unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
52105    for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_>
52106{
52107}
52108unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {}
52109impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52110    type Target = VideoEncodeH264RateControlLayerInfoEXT;
52111    fn deref(&self) -> &Self::Target {
52112        &self.inner
52113    }
52114}
52115impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52116    fn deref_mut(&mut self) -> &mut Self::Target {
52117        &mut self.inner
52118    }
52119}
52120impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
52121    pub fn temporal_layer_id(mut self, temporal_layer_id: u8) -> Self {
52122        self.inner.temporal_layer_id = temporal_layer_id;
52123        self
52124    }
52125    pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
52126        self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
52127        self
52128    }
52129    pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self {
52130        self.inner.initial_rc_qp = initial_rc_qp;
52131        self
52132    }
52133    pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
52134        self.inner.use_min_qp = use_min_qp.into();
52135        self
52136    }
52137    pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self {
52138        self.inner.min_qp = min_qp;
52139        self
52140    }
52141    pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
52142        self.inner.use_max_qp = use_max_qp.into();
52143        self
52144    }
52145    pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self {
52146        self.inner.max_qp = max_qp;
52147        self
52148    }
52149    pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
52150        self.inner.use_max_frame_size = use_max_frame_size.into();
52151        self
52152    }
52153    pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self {
52154        self.inner.max_frame_size = max_frame_size;
52155        self
52156    }
52157    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52158    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52159    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52160    pub fn build(self) -> VideoEncodeH264RateControlLayerInfoEXT {
52161        self.inner
52162    }
52163}
52164#[repr(C)]
52165#[cfg_attr(feature = "debug", derive(Debug))]
52166#[derive(Copy, Clone)]
52167#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CapabilitiesEXT.html>"]
52168pub struct VideoEncodeH265CapabilitiesEXT {
52169    pub s_type: StructureType,
52170    pub p_next: *const c_void,
52171    pub flags: VideoEncodeH265CapabilityFlagsEXT,
52172    pub input_mode_flags: VideoEncodeH265InputModeFlagsEXT,
52173    pub output_mode_flags: VideoEncodeH265OutputModeFlagsEXT,
52174    pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT,
52175    pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
52176    pub max_p_picture_l0_reference_count: u8,
52177    pub max_b_picture_l0_reference_count: u8,
52178    pub max_l1_reference_count: u8,
52179    pub max_sub_layers_count: u8,
52180    pub min_log2_min_luma_coding_block_size_minus3: u8,
52181    pub max_log2_min_luma_coding_block_size_minus3: u8,
52182    pub min_log2_min_luma_transform_block_size_minus2: u8,
52183    pub max_log2_min_luma_transform_block_size_minus2: u8,
52184    pub min_max_transform_hierarchy_depth_inter: u8,
52185    pub max_max_transform_hierarchy_depth_inter: u8,
52186    pub min_max_transform_hierarchy_depth_intra: u8,
52187    pub max_max_transform_hierarchy_depth_intra: u8,
52188    pub max_diff_cu_qp_delta_depth: u8,
52189    pub min_max_num_merge_cand: u8,
52190    pub max_max_num_merge_cand: u8,
52191}
52192impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT {
52193    fn default() -> Self {
52194        Self {
52195            s_type: StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT,
52196            p_next: ::std::ptr::null(),
52197            flags: VideoEncodeH265CapabilityFlagsEXT::default(),
52198            input_mode_flags: VideoEncodeH265InputModeFlagsEXT::default(),
52199            output_mode_flags: VideoEncodeH265OutputModeFlagsEXT::default(),
52200            ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(),
52201            transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(),
52202            max_p_picture_l0_reference_count: u8::default(),
52203            max_b_picture_l0_reference_count: u8::default(),
52204            max_l1_reference_count: u8::default(),
52205            max_sub_layers_count: u8::default(),
52206            min_log2_min_luma_coding_block_size_minus3: u8::default(),
52207            max_log2_min_luma_coding_block_size_minus3: u8::default(),
52208            min_log2_min_luma_transform_block_size_minus2: u8::default(),
52209            max_log2_min_luma_transform_block_size_minus2: u8::default(),
52210            min_max_transform_hierarchy_depth_inter: u8::default(),
52211            max_max_transform_hierarchy_depth_inter: u8::default(),
52212            min_max_transform_hierarchy_depth_intra: u8::default(),
52213            max_max_transform_hierarchy_depth_intra: u8::default(),
52214            max_diff_cu_qp_delta_depth: u8::default(),
52215            min_max_num_merge_cand: u8::default(),
52216            max_max_num_merge_cand: u8::default(),
52217        }
52218    }
52219}
52220impl VideoEncodeH265CapabilitiesEXT {
52221    pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52222        VideoEncodeH265CapabilitiesEXTBuilder {
52223            inner: Self::default(),
52224            marker: ::std::marker::PhantomData,
52225        }
52226    }
52227}
52228#[repr(transparent)]
52229pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52230    inner: VideoEncodeH265CapabilitiesEXT,
52231    marker: ::std::marker::PhantomData<&'a ()>,
52232}
52233unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {}
52234unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {}
52235impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52236    type Target = VideoEncodeH265CapabilitiesEXT;
52237    fn deref(&self) -> &Self::Target {
52238        &self.inner
52239    }
52240}
52241impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52242    fn deref_mut(&mut self) -> &mut Self::Target {
52243        &mut self.inner
52244    }
52245}
52246impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
52247    pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self {
52248        self.inner.flags = flags;
52249        self
52250    }
52251    pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH265InputModeFlagsEXT) -> Self {
52252        self.inner.input_mode_flags = input_mode_flags;
52253        self
52254    }
52255    pub fn output_mode_flags(
52256        mut self,
52257        output_mode_flags: VideoEncodeH265OutputModeFlagsEXT,
52258    ) -> Self {
52259        self.inner.output_mode_flags = output_mode_flags;
52260        self
52261    }
52262    pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self {
52263        self.inner.ctb_sizes = ctb_sizes;
52264        self
52265    }
52266    pub fn transform_block_sizes(
52267        mut self,
52268        transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
52269    ) -> Self {
52270        self.inner.transform_block_sizes = transform_block_sizes;
52271        self
52272    }
52273    pub fn max_p_picture_l0_reference_count(
52274        mut self,
52275        max_p_picture_l0_reference_count: u8,
52276    ) -> Self {
52277        self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
52278        self
52279    }
52280    pub fn max_b_picture_l0_reference_count(
52281        mut self,
52282        max_b_picture_l0_reference_count: u8,
52283    ) -> Self {
52284        self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
52285        self
52286    }
52287    pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self {
52288        self.inner.max_l1_reference_count = max_l1_reference_count;
52289        self
52290    }
52291    pub fn max_sub_layers_count(mut self, max_sub_layers_count: u8) -> Self {
52292        self.inner.max_sub_layers_count = max_sub_layers_count;
52293        self
52294    }
52295    pub fn min_log2_min_luma_coding_block_size_minus3(
52296        mut self,
52297        min_log2_min_luma_coding_block_size_minus3: u8,
52298    ) -> Self {
52299        self.inner.min_log2_min_luma_coding_block_size_minus3 =
52300            min_log2_min_luma_coding_block_size_minus3;
52301        self
52302    }
52303    pub fn max_log2_min_luma_coding_block_size_minus3(
52304        mut self,
52305        max_log2_min_luma_coding_block_size_minus3: u8,
52306    ) -> Self {
52307        self.inner.max_log2_min_luma_coding_block_size_minus3 =
52308            max_log2_min_luma_coding_block_size_minus3;
52309        self
52310    }
52311    pub fn min_log2_min_luma_transform_block_size_minus2(
52312        mut self,
52313        min_log2_min_luma_transform_block_size_minus2: u8,
52314    ) -> Self {
52315        self.inner.min_log2_min_luma_transform_block_size_minus2 =
52316            min_log2_min_luma_transform_block_size_minus2;
52317        self
52318    }
52319    pub fn max_log2_min_luma_transform_block_size_minus2(
52320        mut self,
52321        max_log2_min_luma_transform_block_size_minus2: u8,
52322    ) -> Self {
52323        self.inner.max_log2_min_luma_transform_block_size_minus2 =
52324            max_log2_min_luma_transform_block_size_minus2;
52325        self
52326    }
52327    pub fn min_max_transform_hierarchy_depth_inter(
52328        mut self,
52329        min_max_transform_hierarchy_depth_inter: u8,
52330    ) -> Self {
52331        self.inner.min_max_transform_hierarchy_depth_inter =
52332            min_max_transform_hierarchy_depth_inter;
52333        self
52334    }
52335    pub fn max_max_transform_hierarchy_depth_inter(
52336        mut self,
52337        max_max_transform_hierarchy_depth_inter: u8,
52338    ) -> Self {
52339        self.inner.max_max_transform_hierarchy_depth_inter =
52340            max_max_transform_hierarchy_depth_inter;
52341        self
52342    }
52343    pub fn min_max_transform_hierarchy_depth_intra(
52344        mut self,
52345        min_max_transform_hierarchy_depth_intra: u8,
52346    ) -> Self {
52347        self.inner.min_max_transform_hierarchy_depth_intra =
52348            min_max_transform_hierarchy_depth_intra;
52349        self
52350    }
52351    pub fn max_max_transform_hierarchy_depth_intra(
52352        mut self,
52353        max_max_transform_hierarchy_depth_intra: u8,
52354    ) -> Self {
52355        self.inner.max_max_transform_hierarchy_depth_intra =
52356            max_max_transform_hierarchy_depth_intra;
52357        self
52358    }
52359    pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u8) -> Self {
52360        self.inner.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth;
52361        self
52362    }
52363    pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u8) -> Self {
52364        self.inner.min_max_num_merge_cand = min_max_num_merge_cand;
52365        self
52366    }
52367    pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u8) -> Self {
52368        self.inner.max_max_num_merge_cand = max_max_num_merge_cand;
52369        self
52370    }
52371    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52372    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52373    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52374    pub fn build(self) -> VideoEncodeH265CapabilitiesEXT {
52375        self.inner
52376    }
52377}
52378#[repr(C)]
52379#[cfg_attr(feature = "debug", derive(Debug))]
52380#[derive(Copy, Clone)]
52381#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersAddInfoEXT.html>"]
52382pub struct VideoEncodeH265SessionParametersAddInfoEXT {
52383    pub s_type: StructureType,
52384    pub p_next: *const c_void,
52385    pub vps_std_count: u32,
52386    pub p_vps_std: *const StdVideoH265VideoParameterSet,
52387    pub sps_std_count: u32,
52388    pub p_sps_std: *const StdVideoH265SequenceParameterSet,
52389    pub pps_std_count: u32,
52390    pub p_pps_std: *const StdVideoH265PictureParameterSet,
52391}
52392impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT {
52393    fn default() -> Self {
52394        Self {
52395            s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT,
52396            p_next: ::std::ptr::null(),
52397            vps_std_count: u32::default(),
52398            p_vps_std: ::std::ptr::null(),
52399            sps_std_count: u32::default(),
52400            p_sps_std: ::std::ptr::null(),
52401            pps_std_count: u32::default(),
52402            p_pps_std: ::std::ptr::null(),
52403        }
52404    }
52405}
52406impl VideoEncodeH265SessionParametersAddInfoEXT {
52407    pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52408        VideoEncodeH265SessionParametersAddInfoEXTBuilder {
52409            inner: Self::default(),
52410            marker: ::std::marker::PhantomData,
52411        }
52412    }
52413}
52414#[repr(transparent)]
52415pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52416    inner: VideoEncodeH265SessionParametersAddInfoEXT,
52417    marker: ::std::marker::PhantomData<&'a ()>,
52418}
52419unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
52420    for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_>
52421{
52422}
52423unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
52424    for VideoEncodeH265SessionParametersAddInfoEXT
52425{
52426}
52427impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52428    type Target = VideoEncodeH265SessionParametersAddInfoEXT;
52429    fn deref(&self) -> &Self::Target {
52430        &self.inner
52431    }
52432}
52433impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52434    fn deref_mut(&mut self) -> &mut Self::Target {
52435        &mut self.inner
52436    }
52437}
52438impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
52439    pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self {
52440        self.inner.vps_std_count = vps_std.len() as _;
52441        self.inner.p_vps_std = vps_std.as_ptr();
52442        self
52443    }
52444    pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self {
52445        self.inner.sps_std_count = sps_std.len() as _;
52446        self.inner.p_sps_std = sps_std.as_ptr();
52447        self
52448    }
52449    pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self {
52450        self.inner.pps_std_count = pps_std.len() as _;
52451        self.inner.p_pps_std = pps_std.as_ptr();
52452        self
52453    }
52454    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52455    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52456    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52457    pub fn build(self) -> VideoEncodeH265SessionParametersAddInfoEXT {
52458        self.inner
52459    }
52460}
52461#[repr(C)]
52462#[cfg_attr(feature = "debug", derive(Debug))]
52463#[derive(Copy, Clone)]
52464#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersCreateInfoEXT.html>"]
52465pub struct VideoEncodeH265SessionParametersCreateInfoEXT {
52466    pub s_type: StructureType,
52467    pub p_next: *const c_void,
52468    pub max_vps_std_count: u32,
52469    pub max_sps_std_count: u32,
52470    pub max_pps_std_count: u32,
52471    pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT,
52472}
52473impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT {
52474    fn default() -> Self {
52475        Self {
52476            s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT,
52477            p_next: ::std::ptr::null(),
52478            max_vps_std_count: u32::default(),
52479            max_sps_std_count: u32::default(),
52480            max_pps_std_count: u32::default(),
52481            p_parameters_add_info: ::std::ptr::null(),
52482        }
52483    }
52484}
52485impl VideoEncodeH265SessionParametersCreateInfoEXT {
52486    pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52487        VideoEncodeH265SessionParametersCreateInfoEXTBuilder {
52488            inner: Self::default(),
52489            marker: ::std::marker::PhantomData,
52490        }
52491    }
52492}
52493#[repr(transparent)]
52494pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52495    inner: VideoEncodeH265SessionParametersCreateInfoEXT,
52496    marker: ::std::marker::PhantomData<&'a ()>,
52497}
52498unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
52499    for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_>
52500{
52501}
52502unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
52503    for VideoEncodeH265SessionParametersCreateInfoEXT
52504{
52505}
52506impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52507    type Target = VideoEncodeH265SessionParametersCreateInfoEXT;
52508    fn deref(&self) -> &Self::Target {
52509        &self.inner
52510    }
52511}
52512impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52513    fn deref_mut(&mut self) -> &mut Self::Target {
52514        &mut self.inner
52515    }
52516}
52517impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
52518    pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self {
52519        self.inner.max_vps_std_count = max_vps_std_count;
52520        self
52521    }
52522    pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
52523        self.inner.max_sps_std_count = max_sps_std_count;
52524        self
52525    }
52526    pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
52527        self.inner.max_pps_std_count = max_pps_std_count;
52528        self
52529    }
52530    pub fn parameters_add_info(
52531        mut self,
52532        parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT,
52533    ) -> Self {
52534        self.inner.p_parameters_add_info = parameters_add_info;
52535        self
52536    }
52537    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52538    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52539    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52540    pub fn build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT {
52541        self.inner
52542    }
52543}
52544#[repr(C)]
52545#[cfg_attr(feature = "debug", derive(Debug))]
52546#[derive(Copy, Clone)]
52547#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265VclFrameInfoEXT.html>"]
52548pub struct VideoEncodeH265VclFrameInfoEXT {
52549    pub s_type: StructureType,
52550    pub p_next: *const c_void,
52551    pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT,
52552    pub nalu_slice_segment_entry_count: u32,
52553    pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentEXT,
52554    pub p_current_picture_info: *const StdVideoEncodeH265PictureInfo,
52555}
52556impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT {
52557    fn default() -> Self {
52558        Self {
52559            s_type: StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT,
52560            p_next: ::std::ptr::null(),
52561            p_reference_final_lists: ::std::ptr::null(),
52562            nalu_slice_segment_entry_count: u32::default(),
52563            p_nalu_slice_segment_entries: ::std::ptr::null(),
52564            p_current_picture_info: ::std::ptr::null(),
52565        }
52566    }
52567}
52568impl VideoEncodeH265VclFrameInfoEXT {
52569    pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52570        VideoEncodeH265VclFrameInfoEXTBuilder {
52571            inner: Self::default(),
52572            marker: ::std::marker::PhantomData,
52573        }
52574    }
52575}
52576#[repr(transparent)]
52577pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52578    inner: VideoEncodeH265VclFrameInfoEXT,
52579    marker: ::std::marker::PhantomData<&'a ()>,
52580}
52581unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {}
52582unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {}
52583impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52584    type Target = VideoEncodeH265VclFrameInfoEXT;
52585    fn deref(&self) -> &Self::Target {
52586        &self.inner
52587    }
52588}
52589impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52590    fn deref_mut(&mut self) -> &mut Self::Target {
52591        &mut self.inner
52592    }
52593}
52594impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
52595    pub fn reference_final_lists(
52596        mut self,
52597        reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT,
52598    ) -> Self {
52599        self.inner.p_reference_final_lists = reference_final_lists;
52600        self
52601    }
52602    pub fn nalu_slice_segment_entries(
52603        mut self,
52604        nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentEXT],
52605    ) -> Self {
52606        self.inner.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _;
52607        self.inner.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr();
52608        self
52609    }
52610    pub fn current_picture_info(
52611        mut self,
52612        current_picture_info: &'a StdVideoEncodeH265PictureInfo,
52613    ) -> Self {
52614        self.inner.p_current_picture_info = current_picture_info;
52615        self
52616    }
52617    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52618    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52619    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52620    pub fn build(self) -> VideoEncodeH265VclFrameInfoEXT {
52621        self.inner
52622    }
52623}
52624#[repr(C)]
52625#[cfg_attr(feature = "debug", derive(Debug))]
52626#[derive(Copy, Clone)]
52627#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265EmitPictureParametersEXT.html>"]
52628pub struct VideoEncodeH265EmitPictureParametersEXT {
52629    pub s_type: StructureType,
52630    pub p_next: *const c_void,
52631    pub vps_id: u8,
52632    pub sps_id: u8,
52633    pub emit_vps_enable: Bool32,
52634    pub emit_sps_enable: Bool32,
52635    pub pps_id_entry_count: u32,
52636    pub pps_id_entries: *const u8,
52637}
52638impl ::std::default::Default for VideoEncodeH265EmitPictureParametersEXT {
52639    fn default() -> Self {
52640        Self {
52641            s_type: StructureType::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT,
52642            p_next: ::std::ptr::null(),
52643            vps_id: u8::default(),
52644            sps_id: u8::default(),
52645            emit_vps_enable: Bool32::default(),
52646            emit_sps_enable: Bool32::default(),
52647            pps_id_entry_count: u32::default(),
52648            pps_id_entries: ::std::ptr::null(),
52649        }
52650    }
52651}
52652impl VideoEncodeH265EmitPictureParametersEXT {
52653    pub fn builder<'a>() -> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52654        VideoEncodeH265EmitPictureParametersEXTBuilder {
52655            inner: Self::default(),
52656            marker: ::std::marker::PhantomData,
52657        }
52658    }
52659}
52660#[repr(transparent)]
52661pub struct VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52662    inner: VideoEncodeH265EmitPictureParametersEXT,
52663    marker: ::std::marker::PhantomData<&'a ()>,
52664}
52665unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXTBuilder<'_> {}
52666unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXT {}
52667impl<'a> ::std::ops::Deref for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52668    type Target = VideoEncodeH265EmitPictureParametersEXT;
52669    fn deref(&self) -> &Self::Target {
52670        &self.inner
52671    }
52672}
52673impl<'a> ::std::ops::DerefMut for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52674    fn deref_mut(&mut self) -> &mut Self::Target {
52675        &mut self.inner
52676    }
52677}
52678impl<'a> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> {
52679    pub fn vps_id(mut self, vps_id: u8) -> Self {
52680        self.inner.vps_id = vps_id;
52681        self
52682    }
52683    pub fn sps_id(mut self, sps_id: u8) -> Self {
52684        self.inner.sps_id = sps_id;
52685        self
52686    }
52687    pub fn emit_vps_enable(mut self, emit_vps_enable: bool) -> Self {
52688        self.inner.emit_vps_enable = emit_vps_enable.into();
52689        self
52690    }
52691    pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self {
52692        self.inner.emit_sps_enable = emit_sps_enable.into();
52693        self
52694    }
52695    pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self {
52696        self.inner.pps_id_entry_count = pps_id_entries.len() as _;
52697        self.inner.pps_id_entries = pps_id_entries.as_ptr();
52698        self
52699    }
52700    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52701    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52702    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52703    pub fn build(self) -> VideoEncodeH265EmitPictureParametersEXT {
52704        self.inner
52705    }
52706}
52707#[repr(C)]
52708#[cfg_attr(feature = "debug", derive(Debug))]
52709#[derive(Copy, Clone)]
52710#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265NaluSliceSegmentEXT.html>"]
52711pub struct VideoEncodeH265NaluSliceSegmentEXT {
52712    pub s_type: StructureType,
52713    pub p_next: *const c_void,
52714    pub ctb_count: u32,
52715    pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT,
52716    pub p_slice_segment_header_std: *const StdVideoEncodeH265SliceSegmentHeader,
52717}
52718impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentEXT {
52719    fn default() -> Self {
52720        Self {
52721            s_type: StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT,
52722            p_next: ::std::ptr::null(),
52723            ctb_count: u32::default(),
52724            p_reference_final_lists: ::std::ptr::null(),
52725            p_slice_segment_header_std: ::std::ptr::null(),
52726        }
52727    }
52728}
52729impl VideoEncodeH265NaluSliceSegmentEXT {
52730    pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52731        VideoEncodeH265NaluSliceSegmentEXTBuilder {
52732            inner: Self::default(),
52733            marker: ::std::marker::PhantomData,
52734        }
52735    }
52736}
52737#[repr(transparent)]
52738pub struct VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52739    inner: VideoEncodeH265NaluSliceSegmentEXT,
52740    marker: ::std::marker::PhantomData<&'a ()>,
52741}
52742impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52743    type Target = VideoEncodeH265NaluSliceSegmentEXT;
52744    fn deref(&self) -> &Self::Target {
52745        &self.inner
52746    }
52747}
52748impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52749    fn deref_mut(&mut self) -> &mut Self::Target {
52750        &mut self.inner
52751    }
52752}
52753impl<'a> VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> {
52754    pub fn ctb_count(mut self, ctb_count: u32) -> Self {
52755        self.inner.ctb_count = ctb_count;
52756        self
52757    }
52758    pub fn reference_final_lists(
52759        mut self,
52760        reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT,
52761    ) -> Self {
52762        self.inner.p_reference_final_lists = reference_final_lists;
52763        self
52764    }
52765    pub fn slice_segment_header_std(
52766        mut self,
52767        slice_segment_header_std: &'a StdVideoEncodeH265SliceSegmentHeader,
52768    ) -> Self {
52769        self.inner.p_slice_segment_header_std = slice_segment_header_std;
52770        self
52771    }
52772    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52773    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52774    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52775    pub fn build(self) -> VideoEncodeH265NaluSliceSegmentEXT {
52776        self.inner
52777    }
52778}
52779#[repr(C)]
52780#[cfg_attr(feature = "debug", derive(Debug))]
52781#[derive(Copy, Clone)]
52782#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlInfoEXT.html>"]
52783pub struct VideoEncodeH265RateControlInfoEXT {
52784    pub s_type: StructureType,
52785    pub p_next: *const c_void,
52786    pub gop_frame_count: u32,
52787    pub idr_period: u32,
52788    pub consecutive_b_frame_count: u32,
52789    pub rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT,
52790    pub sub_layer_count: u8,
52791}
52792impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT {
52793    fn default() -> Self {
52794        Self {
52795            s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT,
52796            p_next: ::std::ptr::null(),
52797            gop_frame_count: u32::default(),
52798            idr_period: u32::default(),
52799            consecutive_b_frame_count: u32::default(),
52800            rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT::default(),
52801            sub_layer_count: u8::default(),
52802        }
52803    }
52804}
52805impl VideoEncodeH265RateControlInfoEXT {
52806    pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52807        VideoEncodeH265RateControlInfoEXTBuilder {
52808            inner: Self::default(),
52809            marker: ::std::marker::PhantomData,
52810        }
52811    }
52812}
52813#[repr(transparent)]
52814pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52815    inner: VideoEncodeH265RateControlInfoEXT,
52816    marker: ::std::marker::PhantomData<&'a ()>,
52817}
52818unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {}
52819unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXT {}
52820impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52821    type Target = VideoEncodeH265RateControlInfoEXT;
52822    fn deref(&self) -> &Self::Target {
52823        &self.inner
52824    }
52825}
52826impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52827    fn deref_mut(&mut self) -> &mut Self::Target {
52828        &mut self.inner
52829    }
52830}
52831impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
52832    pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
52833        self.inner.gop_frame_count = gop_frame_count;
52834        self
52835    }
52836    pub fn idr_period(mut self, idr_period: u32) -> Self {
52837        self.inner.idr_period = idr_period;
52838        self
52839    }
52840    pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
52841        self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
52842        self
52843    }
52844    pub fn rate_control_structure(
52845        mut self,
52846        rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT,
52847    ) -> Self {
52848        self.inner.rate_control_structure = rate_control_structure;
52849        self
52850    }
52851    pub fn sub_layer_count(mut self, sub_layer_count: u8) -> Self {
52852        self.inner.sub_layer_count = sub_layer_count;
52853        self
52854    }
52855    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52856    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52857    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52858    pub fn build(self) -> VideoEncodeH265RateControlInfoEXT {
52859        self.inner
52860    }
52861}
52862#[repr(C)]
52863#[cfg_attr(feature = "debug", derive(Debug))]
52864#[derive(Copy, Clone, Default)]
52865#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265QpEXT.html>"]
52866pub struct VideoEncodeH265QpEXT {
52867    pub qp_i: i32,
52868    pub qp_p: i32,
52869    pub qp_b: i32,
52870}
52871impl VideoEncodeH265QpEXT {
52872    pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> {
52873        VideoEncodeH265QpEXTBuilder {
52874            inner: Self::default(),
52875            marker: ::std::marker::PhantomData,
52876        }
52877    }
52878}
52879#[repr(transparent)]
52880pub struct VideoEncodeH265QpEXTBuilder<'a> {
52881    inner: VideoEncodeH265QpEXT,
52882    marker: ::std::marker::PhantomData<&'a ()>,
52883}
52884impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> {
52885    type Target = VideoEncodeH265QpEXT;
52886    fn deref(&self) -> &Self::Target {
52887        &self.inner
52888    }
52889}
52890impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> {
52891    fn deref_mut(&mut self) -> &mut Self::Target {
52892        &mut self.inner
52893    }
52894}
52895impl<'a> VideoEncodeH265QpEXTBuilder<'a> {
52896    pub fn qp_i(mut self, qp_i: i32) -> Self {
52897        self.inner.qp_i = qp_i;
52898        self
52899    }
52900    pub fn qp_p(mut self, qp_p: i32) -> Self {
52901        self.inner.qp_p = qp_p;
52902        self
52903    }
52904    pub fn qp_b(mut self, qp_b: i32) -> Self {
52905        self.inner.qp_b = qp_b;
52906        self
52907    }
52908    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52909    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52910    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52911    pub fn build(self) -> VideoEncodeH265QpEXT {
52912        self.inner
52913    }
52914}
52915#[repr(C)]
52916#[cfg_attr(feature = "debug", derive(Debug))]
52917#[derive(Copy, Clone, Default)]
52918#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265FrameSizeEXT.html>"]
52919pub struct VideoEncodeH265FrameSizeEXT {
52920    pub frame_i_size: u32,
52921    pub frame_p_size: u32,
52922    pub frame_b_size: u32,
52923}
52924impl VideoEncodeH265FrameSizeEXT {
52925    pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> {
52926        VideoEncodeH265FrameSizeEXTBuilder {
52927            inner: Self::default(),
52928            marker: ::std::marker::PhantomData,
52929        }
52930    }
52931}
52932#[repr(transparent)]
52933pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> {
52934    inner: VideoEncodeH265FrameSizeEXT,
52935    marker: ::std::marker::PhantomData<&'a ()>,
52936}
52937impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> {
52938    type Target = VideoEncodeH265FrameSizeEXT;
52939    fn deref(&self) -> &Self::Target {
52940        &self.inner
52941    }
52942}
52943impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> {
52944    fn deref_mut(&mut self) -> &mut Self::Target {
52945        &mut self.inner
52946    }
52947}
52948impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> {
52949    pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
52950        self.inner.frame_i_size = frame_i_size;
52951        self
52952    }
52953    pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
52954        self.inner.frame_p_size = frame_p_size;
52955        self
52956    }
52957    pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
52958        self.inner.frame_b_size = frame_b_size;
52959        self
52960    }
52961    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
52962    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
52963    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
52964    pub fn build(self) -> VideoEncodeH265FrameSizeEXT {
52965        self.inner
52966    }
52967}
52968#[repr(C)]
52969#[cfg_attr(feature = "debug", derive(Debug))]
52970#[derive(Copy, Clone)]
52971#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlLayerInfoEXT.html>"]
52972pub struct VideoEncodeH265RateControlLayerInfoEXT {
52973    pub s_type: StructureType,
52974    pub p_next: *const c_void,
52975    pub temporal_id: u8,
52976    pub use_initial_rc_qp: Bool32,
52977    pub initial_rc_qp: VideoEncodeH265QpEXT,
52978    pub use_min_qp: Bool32,
52979    pub min_qp: VideoEncodeH265QpEXT,
52980    pub use_max_qp: Bool32,
52981    pub max_qp: VideoEncodeH265QpEXT,
52982    pub use_max_frame_size: Bool32,
52983    pub max_frame_size: VideoEncodeH265FrameSizeEXT,
52984}
52985impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT {
52986    fn default() -> Self {
52987        Self {
52988            s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT,
52989            p_next: ::std::ptr::null(),
52990            temporal_id: u8::default(),
52991            use_initial_rc_qp: Bool32::default(),
52992            initial_rc_qp: VideoEncodeH265QpEXT::default(),
52993            use_min_qp: Bool32::default(),
52994            min_qp: VideoEncodeH265QpEXT::default(),
52995            use_max_qp: Bool32::default(),
52996            max_qp: VideoEncodeH265QpEXT::default(),
52997            use_max_frame_size: Bool32::default(),
52998            max_frame_size: VideoEncodeH265FrameSizeEXT::default(),
52999        }
53000    }
53001}
53002impl VideoEncodeH265RateControlLayerInfoEXT {
53003    pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53004        VideoEncodeH265RateControlLayerInfoEXTBuilder {
53005            inner: Self::default(),
53006            marker: ::std::marker::PhantomData,
53007        }
53008    }
53009}
53010#[repr(transparent)]
53011pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53012    inner: VideoEncodeH265RateControlLayerInfoEXT,
53013    marker: ::std::marker::PhantomData<&'a ()>,
53014}
53015unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
53016    for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_>
53017{
53018}
53019unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {}
53020impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53021    type Target = VideoEncodeH265RateControlLayerInfoEXT;
53022    fn deref(&self) -> &Self::Target {
53023        &self.inner
53024    }
53025}
53026impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53027    fn deref_mut(&mut self) -> &mut Self::Target {
53028        &mut self.inner
53029    }
53030}
53031impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
53032    pub fn temporal_id(mut self, temporal_id: u8) -> Self {
53033        self.inner.temporal_id = temporal_id;
53034        self
53035    }
53036    pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
53037        self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
53038        self
53039    }
53040    pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self {
53041        self.inner.initial_rc_qp = initial_rc_qp;
53042        self
53043    }
53044    pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
53045        self.inner.use_min_qp = use_min_qp.into();
53046        self
53047    }
53048    pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self {
53049        self.inner.min_qp = min_qp;
53050        self
53051    }
53052    pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
53053        self.inner.use_max_qp = use_max_qp.into();
53054        self
53055    }
53056    pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self {
53057        self.inner.max_qp = max_qp;
53058        self
53059    }
53060    pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
53061        self.inner.use_max_frame_size = use_max_frame_size.into();
53062        self
53063    }
53064    pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self {
53065        self.inner.max_frame_size = max_frame_size;
53066        self
53067    }
53068    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53069    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53070    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53071    pub fn build(self) -> VideoEncodeH265RateControlLayerInfoEXT {
53072        self.inner
53073    }
53074}
53075#[repr(C)]
53076#[cfg_attr(feature = "debug", derive(Debug))]
53077#[derive(Copy, Clone)]
53078#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265ProfileEXT.html>"]
53079pub struct VideoEncodeH265ProfileEXT {
53080    pub s_type: StructureType,
53081    pub p_next: *const c_void,
53082    pub std_profile_idc: StdVideoH265ProfileIdc,
53083}
53084impl ::std::default::Default for VideoEncodeH265ProfileEXT {
53085    fn default() -> Self {
53086        Self {
53087            s_type: StructureType::VIDEO_ENCODE_H265_PROFILE_EXT,
53088            p_next: ::std::ptr::null(),
53089            std_profile_idc: StdVideoH265ProfileIdc::default(),
53090        }
53091    }
53092}
53093impl VideoEncodeH265ProfileEXT {
53094    pub fn builder<'a>() -> VideoEncodeH265ProfileEXTBuilder<'a> {
53095        VideoEncodeH265ProfileEXTBuilder {
53096            inner: Self::default(),
53097            marker: ::std::marker::PhantomData,
53098        }
53099    }
53100}
53101#[repr(transparent)]
53102pub struct VideoEncodeH265ProfileEXTBuilder<'a> {
53103    inner: VideoEncodeH265ProfileEXT,
53104    marker: ::std::marker::PhantomData<&'a ()>,
53105}
53106unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXTBuilder<'_> {}
53107unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXT {}
53108unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53109unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXT {}
53110unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXTBuilder<'_> {}
53111unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXT {}
53112unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53113unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXT {}
53114unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53115unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXT {}
53116unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {}
53117unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXT {}
53118impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileEXTBuilder<'a> {
53119    type Target = VideoEncodeH265ProfileEXT;
53120    fn deref(&self) -> &Self::Target {
53121        &self.inner
53122    }
53123}
53124impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileEXTBuilder<'a> {
53125    fn deref_mut(&mut self) -> &mut Self::Target {
53126        &mut self.inner
53127    }
53128}
53129impl<'a> VideoEncodeH265ProfileEXTBuilder<'a> {
53130    pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
53131        self.inner.std_profile_idc = std_profile_idc;
53132        self
53133    }
53134    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53135    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53136    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53137    pub fn build(self) -> VideoEncodeH265ProfileEXT {
53138        self.inner
53139    }
53140}
53141#[repr(C)]
53142#[cfg_attr(feature = "debug", derive(Debug))]
53143#[derive(Copy, Clone)]
53144#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265DpbSlotInfoEXT.html>"]
53145pub struct VideoEncodeH265DpbSlotInfoEXT {
53146    pub s_type: StructureType,
53147    pub p_next: *const c_void,
53148    pub slot_index: i8,
53149    pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo,
53150}
53151impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT {
53152    fn default() -> Self {
53153        Self {
53154            s_type: StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT,
53155            p_next: ::std::ptr::null(),
53156            slot_index: i8::default(),
53157            p_std_reference_info: ::std::ptr::null(),
53158        }
53159    }
53160}
53161impl VideoEncodeH265DpbSlotInfoEXT {
53162    pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53163        VideoEncodeH265DpbSlotInfoEXTBuilder {
53164            inner: Self::default(),
53165            marker: ::std::marker::PhantomData,
53166        }
53167    }
53168}
53169#[repr(transparent)]
53170pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53171    inner: VideoEncodeH265DpbSlotInfoEXT,
53172    marker: ::std::marker::PhantomData<&'a ()>,
53173}
53174impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53175    type Target = VideoEncodeH265DpbSlotInfoEXT;
53176    fn deref(&self) -> &Self::Target {
53177        &self.inner
53178    }
53179}
53180impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53181    fn deref_mut(&mut self) -> &mut Self::Target {
53182        &mut self.inner
53183    }
53184}
53185impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
53186    pub fn slot_index(mut self, slot_index: i8) -> Self {
53187        self.inner.slot_index = slot_index;
53188        self
53189    }
53190    pub fn std_reference_info(
53191        mut self,
53192        std_reference_info: &'a StdVideoEncodeH265ReferenceInfo,
53193    ) -> Self {
53194        self.inner.p_std_reference_info = std_reference_info;
53195        self
53196    }
53197    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53198    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53199    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53200    pub fn build(self) -> VideoEncodeH265DpbSlotInfoEXT {
53201        self.inner
53202    }
53203}
53204#[repr(C)]
53205#[cfg_attr(feature = "debug", derive(Debug))]
53206#[derive(Copy, Clone)]
53207#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265ReferenceListsEXT.html>"]
53208pub struct VideoEncodeH265ReferenceListsEXT {
53209    pub s_type: StructureType,
53210    pub p_next: *const c_void,
53211    pub reference_list0_entry_count: u8,
53212    pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT,
53213    pub reference_list1_entry_count: u8,
53214    pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT,
53215    pub p_reference_modifications: *const StdVideoEncodeH265ReferenceModifications,
53216}
53217impl ::std::default::Default for VideoEncodeH265ReferenceListsEXT {
53218    fn default() -> Self {
53219        Self {
53220            s_type: StructureType::VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT,
53221            p_next: ::std::ptr::null(),
53222            reference_list0_entry_count: u8::default(),
53223            p_reference_list0_entries: ::std::ptr::null(),
53224            reference_list1_entry_count: u8::default(),
53225            p_reference_list1_entries: ::std::ptr::null(),
53226            p_reference_modifications: ::std::ptr::null(),
53227        }
53228    }
53229}
53230impl VideoEncodeH265ReferenceListsEXT {
53231    pub fn builder<'a>() -> VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53232        VideoEncodeH265ReferenceListsEXTBuilder {
53233            inner: Self::default(),
53234            marker: ::std::marker::PhantomData,
53235        }
53236    }
53237}
53238#[repr(transparent)]
53239pub struct VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53240    inner: VideoEncodeH265ReferenceListsEXT,
53241    marker: ::std::marker::PhantomData<&'a ()>,
53242}
53243impl<'a> ::std::ops::Deref for VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53244    type Target = VideoEncodeH265ReferenceListsEXT;
53245    fn deref(&self) -> &Self::Target {
53246        &self.inner
53247    }
53248}
53249impl<'a> ::std::ops::DerefMut for VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53250    fn deref_mut(&mut self) -> &mut Self::Target {
53251        &mut self.inner
53252    }
53253}
53254impl<'a> VideoEncodeH265ReferenceListsEXTBuilder<'a> {
53255    pub fn reference_list0_entries(
53256        mut self,
53257        reference_list0_entries: &'a [VideoEncodeH265DpbSlotInfoEXT],
53258    ) -> Self {
53259        self.inner.reference_list0_entry_count = reference_list0_entries.len() as _;
53260        self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr();
53261        self
53262    }
53263    pub fn reference_list1_entries(
53264        mut self,
53265        reference_list1_entries: &'a [VideoEncodeH265DpbSlotInfoEXT],
53266    ) -> Self {
53267        self.inner.reference_list1_entry_count = reference_list1_entries.len() as _;
53268        self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr();
53269        self
53270    }
53271    pub fn reference_modifications(
53272        mut self,
53273        reference_modifications: &'a StdVideoEncodeH265ReferenceModifications,
53274    ) -> Self {
53275        self.inner.p_reference_modifications = reference_modifications;
53276        self
53277    }
53278    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53279    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53280    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53281    pub fn build(self) -> VideoEncodeH265ReferenceListsEXT {
53282        self.inner
53283    }
53284}
53285#[repr(C)]
53286#[cfg_attr(feature = "debug", derive(Debug))]
53287#[derive(Copy, Clone)]
53288#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html>"]
53289pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV {
53290    pub s_type: StructureType,
53291    pub p_next: *mut c_void,
53292    pub inherited_viewport_scissor2_d: Bool32,
53293}
53294impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV {
53295    fn default() -> Self {
53296        Self {
53297            s_type: StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV,
53298            p_next: ::std::ptr::null_mut(),
53299            inherited_viewport_scissor2_d: Bool32::default(),
53300        }
53301    }
53302}
53303impl PhysicalDeviceInheritedViewportScissorFeaturesNV {
53304    pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53305        PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder {
53306            inner: Self::default(),
53307            marker: ::std::marker::PhantomData,
53308        }
53309    }
53310}
53311#[repr(transparent)]
53312pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53313    inner: PhysicalDeviceInheritedViewportScissorFeaturesNV,
53314    marker: ::std::marker::PhantomData<&'a ()>,
53315}
53316unsafe impl ExtendsPhysicalDeviceFeatures2
53317    for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_>
53318{
53319}
53320unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV {}
53321unsafe impl ExtendsDeviceCreateInfo
53322    for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_>
53323{
53324}
53325unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV {}
53326impl<'a> ::std::ops::Deref for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53327    type Target = PhysicalDeviceInheritedViewportScissorFeaturesNV;
53328    fn deref(&self) -> &Self::Target {
53329        &self.inner
53330    }
53331}
53332impl<'a> ::std::ops::DerefMut for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53333    fn deref_mut(&mut self) -> &mut Self::Target {
53334        &mut self.inner
53335    }
53336}
53337impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
53338    pub fn inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self {
53339        self.inner.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into();
53340        self
53341    }
53342    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53343    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53344    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53345    pub fn build(self) -> PhysicalDeviceInheritedViewportScissorFeaturesNV {
53346        self.inner
53347    }
53348}
53349#[repr(C)]
53350#[cfg_attr(feature = "debug", derive(Debug))]
53351#[derive(Copy, Clone)]
53352#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html>"]
53353pub struct CommandBufferInheritanceViewportScissorInfoNV {
53354    pub s_type: StructureType,
53355    pub p_next: *const c_void,
53356    pub viewport_scissor2_d: Bool32,
53357    pub viewport_depth_count: u32,
53358    pub p_viewport_depths: *const Viewport,
53359}
53360impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV {
53361    fn default() -> Self {
53362        Self {
53363            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV,
53364            p_next: ::std::ptr::null(),
53365            viewport_scissor2_d: Bool32::default(),
53366            viewport_depth_count: u32::default(),
53367            p_viewport_depths: ::std::ptr::null(),
53368        }
53369    }
53370}
53371impl CommandBufferInheritanceViewportScissorInfoNV {
53372    pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53373        CommandBufferInheritanceViewportScissorInfoNVBuilder {
53374            inner: Self::default(),
53375            marker: ::std::marker::PhantomData,
53376        }
53377    }
53378}
53379#[repr(transparent)]
53380pub struct CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53381    inner: CommandBufferInheritanceViewportScissorInfoNV,
53382    marker: ::std::marker::PhantomData<&'a ()>,
53383}
53384unsafe impl ExtendsCommandBufferInheritanceInfo
53385    for CommandBufferInheritanceViewportScissorInfoNVBuilder<'_>
53386{
53387}
53388unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceViewportScissorInfoNV {}
53389impl<'a> ::std::ops::Deref for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53390    type Target = CommandBufferInheritanceViewportScissorInfoNV;
53391    fn deref(&self) -> &Self::Target {
53392        &self.inner
53393    }
53394}
53395impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53396    fn deref_mut(&mut self) -> &mut Self::Target {
53397        &mut self.inner
53398    }
53399}
53400impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
53401    pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self {
53402        self.inner.viewport_scissor2_d = viewport_scissor2_d.into();
53403        self
53404    }
53405    pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self {
53406        self.inner.viewport_depth_count = viewport_depth_count;
53407        self
53408    }
53409    pub fn viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self {
53410        self.inner.p_viewport_depths = viewport_depths;
53411        self
53412    }
53413    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53414    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53415    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53416    pub fn build(self) -> CommandBufferInheritanceViewportScissorInfoNV {
53417        self.inner
53418    }
53419}
53420#[repr(C)]
53421#[cfg_attr(feature = "debug", derive(Debug))]
53422#[derive(Copy, Clone)]
53423#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html>"]
53424pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53425    pub s_type: StructureType,
53426    pub p_next: *mut c_void,
53427    pub ycbcr2plane444_formats: Bool32,
53428}
53429impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53430    fn default() -> Self {
53431        Self {
53432            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT,
53433            p_next: ::std::ptr::null_mut(),
53434            ycbcr2plane444_formats: Bool32::default(),
53435        }
53436    }
53437}
53438impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53439    pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53440        PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder {
53441            inner: Self::default(),
53442            marker: ::std::marker::PhantomData,
53443        }
53444    }
53445}
53446#[repr(transparent)]
53447pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53448    inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT,
53449    marker: ::std::marker::PhantomData<&'a ()>,
53450}
53451unsafe impl ExtendsPhysicalDeviceFeatures2
53452    for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_>
53453{
53454}
53455unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {}
53456unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> {}
53457unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {}
53458impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53459    type Target = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
53460    fn deref(&self) -> &Self::Target {
53461        &self.inner
53462    }
53463}
53464impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53465    fn deref_mut(&mut self) -> &mut Self::Target {
53466        &mut self.inner
53467    }
53468}
53469impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
53470    pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self {
53471        self.inner.ycbcr2plane444_formats = ycbcr2plane444_formats.into();
53472        self
53473    }
53474    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53475    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53476    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53477    pub fn build(self) -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
53478        self.inner
53479    }
53480}
53481#[repr(C)]
53482#[cfg_attr(feature = "debug", derive(Debug))]
53483#[derive(Copy, Clone)]
53484#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html>"]
53485pub struct PhysicalDeviceProvokingVertexFeaturesEXT {
53486    pub s_type: StructureType,
53487    pub p_next: *mut c_void,
53488    pub provoking_vertex_last: Bool32,
53489    pub transform_feedback_preserves_provoking_vertex: Bool32,
53490}
53491impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT {
53492    fn default() -> Self {
53493        Self {
53494            s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
53495            p_next: ::std::ptr::null_mut(),
53496            provoking_vertex_last: Bool32::default(),
53497            transform_feedback_preserves_provoking_vertex: Bool32::default(),
53498        }
53499    }
53500}
53501impl PhysicalDeviceProvokingVertexFeaturesEXT {
53502    pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53503        PhysicalDeviceProvokingVertexFeaturesEXTBuilder {
53504            inner: Self::default(),
53505            marker: ::std::marker::PhantomData,
53506        }
53507    }
53508}
53509#[repr(transparent)]
53510pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53511    inner: PhysicalDeviceProvokingVertexFeaturesEXT,
53512    marker: ::std::marker::PhantomData<&'a ()>,
53513}
53514unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {}
53515unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT {}
53516unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {}
53517unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT {}
53518impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53519    type Target = PhysicalDeviceProvokingVertexFeaturesEXT;
53520    fn deref(&self) -> &Self::Target {
53521        &self.inner
53522    }
53523}
53524impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53525    fn deref_mut(&mut self) -> &mut Self::Target {
53526        &mut self.inner
53527    }
53528}
53529impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
53530    pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self {
53531        self.inner.provoking_vertex_last = provoking_vertex_last.into();
53532        self
53533    }
53534    pub fn transform_feedback_preserves_provoking_vertex(
53535        mut self,
53536        transform_feedback_preserves_provoking_vertex: bool,
53537    ) -> Self {
53538        self.inner.transform_feedback_preserves_provoking_vertex =
53539            transform_feedback_preserves_provoking_vertex.into();
53540        self
53541    }
53542    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53543    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53544    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53545    pub fn build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT {
53546        self.inner
53547    }
53548}
53549#[repr(C)]
53550#[cfg_attr(feature = "debug", derive(Debug))]
53551#[derive(Copy, Clone)]
53552#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html>"]
53553pub struct PhysicalDeviceProvokingVertexPropertiesEXT {
53554    pub s_type: StructureType,
53555    pub p_next: *mut c_void,
53556    pub provoking_vertex_mode_per_pipeline: Bool32,
53557    pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32,
53558}
53559impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT {
53560    fn default() -> Self {
53561        Self {
53562            s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT,
53563            p_next: ::std::ptr::null_mut(),
53564            provoking_vertex_mode_per_pipeline: Bool32::default(),
53565            transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(),
53566        }
53567    }
53568}
53569impl PhysicalDeviceProvokingVertexPropertiesEXT {
53570    pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53571        PhysicalDeviceProvokingVertexPropertiesEXTBuilder {
53572            inner: Self::default(),
53573            marker: ::std::marker::PhantomData,
53574        }
53575    }
53576}
53577#[repr(transparent)]
53578pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53579    inner: PhysicalDeviceProvokingVertexPropertiesEXT,
53580    marker: ::std::marker::PhantomData<&'a ()>,
53581}
53582unsafe impl ExtendsPhysicalDeviceProperties2
53583    for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'_>
53584{
53585}
53586unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT {}
53587impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53588    type Target = PhysicalDeviceProvokingVertexPropertiesEXT;
53589    fn deref(&self) -> &Self::Target {
53590        &self.inner
53591    }
53592}
53593impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53594    fn deref_mut(&mut self) -> &mut Self::Target {
53595        &mut self.inner
53596    }
53597}
53598impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
53599    pub fn provoking_vertex_mode_per_pipeline(
53600        mut self,
53601        provoking_vertex_mode_per_pipeline: bool,
53602    ) -> Self {
53603        self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into();
53604        self
53605    }
53606    pub fn transform_feedback_preserves_triangle_fan_provoking_vertex(
53607        mut self,
53608        transform_feedback_preserves_triangle_fan_provoking_vertex: bool,
53609    ) -> Self {
53610        self.inner
53611            .transform_feedback_preserves_triangle_fan_provoking_vertex =
53612            transform_feedback_preserves_triangle_fan_provoking_vertex.into();
53613        self
53614    }
53615    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53616    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53617    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53618    pub fn build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT {
53619        self.inner
53620    }
53621}
53622#[repr(C)]
53623#[cfg_attr(feature = "debug", derive(Debug))]
53624#[derive(Copy, Clone)]
53625#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html>"]
53626pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53627    pub s_type: StructureType,
53628    pub p_next: *const c_void,
53629    pub provoking_vertex_mode: ProvokingVertexModeEXT,
53630}
53631impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53632    fn default() -> Self {
53633        Self {
53634            s_type: StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT,
53635            p_next: ::std::ptr::null(),
53636            provoking_vertex_mode: ProvokingVertexModeEXT::default(),
53637        }
53638    }
53639}
53640impl PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53641    pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53642        PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder {
53643            inner: Self::default(),
53644            marker: ::std::marker::PhantomData,
53645        }
53646    }
53647}
53648#[repr(transparent)]
53649pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53650    inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT,
53651    marker: ::std::marker::PhantomData<&'a ()>,
53652}
53653unsafe impl ExtendsPipelineRasterizationStateCreateInfo
53654    for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'_>
53655{
53656}
53657unsafe impl ExtendsPipelineRasterizationStateCreateInfo
53658    for PipelineRasterizationProvokingVertexStateCreateInfoEXT
53659{
53660}
53661impl<'a> ::std::ops::Deref for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53662    type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT;
53663    fn deref(&self) -> &Self::Target {
53664        &self.inner
53665    }
53666}
53667impl<'a> ::std::ops::DerefMut
53668    for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a>
53669{
53670    fn deref_mut(&mut self) -> &mut Self::Target {
53671        &mut self.inner
53672    }
53673}
53674impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
53675    pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self {
53676        self.inner.provoking_vertex_mode = provoking_vertex_mode;
53677        self
53678    }
53679    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53680    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53681    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53682    pub fn build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT {
53683        self.inner
53684    }
53685}
53686#[repr(C)]
53687#[cfg_attr(feature = "debug", derive(Debug))]
53688#[derive(Copy, Clone)]
53689#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleCreateInfoNVX.html>"]
53690pub struct CuModuleCreateInfoNVX {
53691    pub s_type: StructureType,
53692    pub p_next: *const c_void,
53693    pub data_size: usize,
53694    pub p_data: *const c_void,
53695}
53696impl ::std::default::Default for CuModuleCreateInfoNVX {
53697    fn default() -> Self {
53698        Self {
53699            s_type: StructureType::CU_MODULE_CREATE_INFO_NVX,
53700            p_next: ::std::ptr::null(),
53701            data_size: usize::default(),
53702            p_data: ::std::ptr::null(),
53703        }
53704    }
53705}
53706impl CuModuleCreateInfoNVX {
53707    pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> {
53708        CuModuleCreateInfoNVXBuilder {
53709            inner: Self::default(),
53710            marker: ::std::marker::PhantomData,
53711        }
53712    }
53713}
53714#[repr(transparent)]
53715pub struct CuModuleCreateInfoNVXBuilder<'a> {
53716    inner: CuModuleCreateInfoNVX,
53717    marker: ::std::marker::PhantomData<&'a ()>,
53718}
53719impl<'a> ::std::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> {
53720    type Target = CuModuleCreateInfoNVX;
53721    fn deref(&self) -> &Self::Target {
53722        &self.inner
53723    }
53724}
53725impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> {
53726    fn deref_mut(&mut self) -> &mut Self::Target {
53727        &mut self.inner
53728    }
53729}
53730impl<'a> CuModuleCreateInfoNVXBuilder<'a> {
53731    pub fn data(mut self, data: &'a [u8]) -> Self {
53732        self.inner.data_size = data.len();
53733        self.inner.p_data = data.as_ptr() as *const c_void;
53734        self
53735    }
53736    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53737    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53738    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53739    pub fn build(self) -> CuModuleCreateInfoNVX {
53740        self.inner
53741    }
53742}
53743#[repr(C)]
53744#[cfg_attr(feature = "debug", derive(Debug))]
53745#[derive(Copy, Clone)]
53746#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionCreateInfoNVX.html>"]
53747pub struct CuFunctionCreateInfoNVX {
53748    pub s_type: StructureType,
53749    pub p_next: *const c_void,
53750    pub module: CuModuleNVX,
53751    pub p_name: *const c_char,
53752}
53753impl ::std::default::Default for CuFunctionCreateInfoNVX {
53754    fn default() -> Self {
53755        Self {
53756            s_type: StructureType::CU_FUNCTION_CREATE_INFO_NVX,
53757            p_next: ::std::ptr::null(),
53758            module: CuModuleNVX::default(),
53759            p_name: ::std::ptr::null(),
53760        }
53761    }
53762}
53763impl CuFunctionCreateInfoNVX {
53764    pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> {
53765        CuFunctionCreateInfoNVXBuilder {
53766            inner: Self::default(),
53767            marker: ::std::marker::PhantomData,
53768        }
53769    }
53770}
53771#[repr(transparent)]
53772pub struct CuFunctionCreateInfoNVXBuilder<'a> {
53773    inner: CuFunctionCreateInfoNVX,
53774    marker: ::std::marker::PhantomData<&'a ()>,
53775}
53776impl<'a> ::std::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> {
53777    type Target = CuFunctionCreateInfoNVX;
53778    fn deref(&self) -> &Self::Target {
53779        &self.inner
53780    }
53781}
53782impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> {
53783    fn deref_mut(&mut self) -> &mut Self::Target {
53784        &mut self.inner
53785    }
53786}
53787impl<'a> CuFunctionCreateInfoNVXBuilder<'a> {
53788    pub fn module(mut self, module: CuModuleNVX) -> Self {
53789        self.inner.module = module;
53790        self
53791    }
53792    pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
53793        self.inner.p_name = name.as_ptr();
53794        self
53795    }
53796    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53797    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53798    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53799    pub fn build(self) -> CuFunctionCreateInfoNVX {
53800        self.inner
53801    }
53802}
53803#[repr(C)]
53804#[cfg_attr(feature = "debug", derive(Debug))]
53805#[derive(Copy, Clone)]
53806#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuLaunchInfoNVX.html>"]
53807pub struct CuLaunchInfoNVX {
53808    pub s_type: StructureType,
53809    pub p_next: *const c_void,
53810    pub function: CuFunctionNVX,
53811    pub grid_dim_x: u32,
53812    pub grid_dim_y: u32,
53813    pub grid_dim_z: u32,
53814    pub block_dim_x: u32,
53815    pub block_dim_y: u32,
53816    pub block_dim_z: u32,
53817    pub shared_mem_bytes: u32,
53818    pub param_count: usize,
53819    pub p_params: *const *const c_void,
53820    pub extra_count: usize,
53821    pub p_extras: *const *const c_void,
53822}
53823impl ::std::default::Default for CuLaunchInfoNVX {
53824    fn default() -> Self {
53825        Self {
53826            s_type: StructureType::CU_LAUNCH_INFO_NVX,
53827            p_next: ::std::ptr::null(),
53828            function: CuFunctionNVX::default(),
53829            grid_dim_x: u32::default(),
53830            grid_dim_y: u32::default(),
53831            grid_dim_z: u32::default(),
53832            block_dim_x: u32::default(),
53833            block_dim_y: u32::default(),
53834            block_dim_z: u32::default(),
53835            shared_mem_bytes: u32::default(),
53836            param_count: usize::default(),
53837            p_params: ::std::ptr::null(),
53838            extra_count: usize::default(),
53839            p_extras: ::std::ptr::null(),
53840        }
53841    }
53842}
53843impl CuLaunchInfoNVX {
53844    pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> {
53845        CuLaunchInfoNVXBuilder {
53846            inner: Self::default(),
53847            marker: ::std::marker::PhantomData,
53848        }
53849    }
53850}
53851#[repr(transparent)]
53852pub struct CuLaunchInfoNVXBuilder<'a> {
53853    inner: CuLaunchInfoNVX,
53854    marker: ::std::marker::PhantomData<&'a ()>,
53855}
53856impl<'a> ::std::ops::Deref for CuLaunchInfoNVXBuilder<'a> {
53857    type Target = CuLaunchInfoNVX;
53858    fn deref(&self) -> &Self::Target {
53859        &self.inner
53860    }
53861}
53862impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> {
53863    fn deref_mut(&mut self) -> &mut Self::Target {
53864        &mut self.inner
53865    }
53866}
53867impl<'a> CuLaunchInfoNVXBuilder<'a> {
53868    pub fn function(mut self, function: CuFunctionNVX) -> Self {
53869        self.inner.function = function;
53870        self
53871    }
53872    pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self {
53873        self.inner.grid_dim_x = grid_dim_x;
53874        self
53875    }
53876    pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self {
53877        self.inner.grid_dim_y = grid_dim_y;
53878        self
53879    }
53880    pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self {
53881        self.inner.grid_dim_z = grid_dim_z;
53882        self
53883    }
53884    pub fn block_dim_x(mut self, block_dim_x: u32) -> Self {
53885        self.inner.block_dim_x = block_dim_x;
53886        self
53887    }
53888    pub fn block_dim_y(mut self, block_dim_y: u32) -> Self {
53889        self.inner.block_dim_y = block_dim_y;
53890        self
53891    }
53892    pub fn block_dim_z(mut self, block_dim_z: u32) -> Self {
53893        self.inner.block_dim_z = block_dim_z;
53894        self
53895    }
53896    pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self {
53897        self.inner.shared_mem_bytes = shared_mem_bytes;
53898        self
53899    }
53900    pub fn params(mut self, params: &'a [*const c_void]) -> Self {
53901        self.inner.param_count = params.len();
53902        self.inner.p_params = params.as_ptr();
53903        self
53904    }
53905    pub fn extras(mut self, extras: &'a [*const c_void]) -> Self {
53906        self.inner.extra_count = extras.len();
53907        self.inner.p_extras = extras.as_ptr();
53908        self
53909    }
53910    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53911    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53912    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53913    pub fn build(self) -> CuLaunchInfoNVX {
53914        self.inner
53915    }
53916}
53917#[repr(C)]
53918#[cfg_attr(feature = "debug", derive(Debug))]
53919#[derive(Copy, Clone)]
53920#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductFeatures.html>"]
53921pub struct PhysicalDeviceShaderIntegerDotProductFeatures {
53922    pub s_type: StructureType,
53923    pub p_next: *mut c_void,
53924    pub shader_integer_dot_product: Bool32,
53925}
53926impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures {
53927    fn default() -> Self {
53928        Self {
53929            s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
53930            p_next: ::std::ptr::null_mut(),
53931            shader_integer_dot_product: Bool32::default(),
53932        }
53933    }
53934}
53935impl PhysicalDeviceShaderIntegerDotProductFeatures {
53936    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53937        PhysicalDeviceShaderIntegerDotProductFeaturesBuilder {
53938            inner: Self::default(),
53939            marker: ::std::marker::PhantomData,
53940        }
53941    }
53942}
53943#[repr(transparent)]
53944pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53945    inner: PhysicalDeviceShaderIntegerDotProductFeatures,
53946    marker: ::std::marker::PhantomData<&'a ()>,
53947}
53948unsafe impl ExtendsPhysicalDeviceFeatures2
53949    for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_>
53950{
53951}
53952unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures {}
53953unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> {}
53954unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures {}
53955impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53956    type Target = PhysicalDeviceShaderIntegerDotProductFeatures;
53957    fn deref(&self) -> &Self::Target {
53958        &self.inner
53959    }
53960}
53961impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53962    fn deref_mut(&mut self) -> &mut Self::Target {
53963        &mut self.inner
53964    }
53965}
53966impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
53967    pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
53968        self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
53969        self
53970    }
53971    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
53972    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
53973    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
53974    pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures {
53975        self.inner
53976    }
53977}
53978#[repr(C)]
53979#[cfg_attr(feature = "debug", derive(Debug))]
53980#[derive(Copy, Clone)]
53981#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductProperties.html>"]
53982pub struct PhysicalDeviceShaderIntegerDotProductProperties {
53983    pub s_type: StructureType,
53984    pub p_next: *mut c_void,
53985    pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
53986    pub integer_dot_product8_bit_signed_accelerated: Bool32,
53987    pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
53988    pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
53989    pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
53990    pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
53991    pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
53992    pub integer_dot_product16_bit_signed_accelerated: Bool32,
53993    pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
53994    pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
53995    pub integer_dot_product32_bit_signed_accelerated: Bool32,
53996    pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
53997    pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
53998    pub integer_dot_product64_bit_signed_accelerated: Bool32,
53999    pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
54000    pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
54001    pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
54002    pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
54003    pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
54004    pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
54005    pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
54006        Bool32,
54007    pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
54008    pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
54009    pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
54010    pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
54011    pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
54012    pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
54013    pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
54014    pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
54015    pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
54016}
54017impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties {
54018    fn default() -> Self {
54019        Self { s_type : StructureType :: PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () }
54020    }
54021}
54022impl PhysicalDeviceShaderIntegerDotProductProperties {
54023    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54024        PhysicalDeviceShaderIntegerDotProductPropertiesBuilder {
54025            inner: Self::default(),
54026            marker: ::std::marker::PhantomData,
54027        }
54028    }
54029}
54030#[repr(transparent)]
54031pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54032    inner: PhysicalDeviceShaderIntegerDotProductProperties,
54033    marker: ::std::marker::PhantomData<&'a ()>,
54034}
54035unsafe impl ExtendsPhysicalDeviceProperties2
54036    for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'_>
54037{
54038}
54039unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties {}
54040impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54041    type Target = PhysicalDeviceShaderIntegerDotProductProperties;
54042    fn deref(&self) -> &Self::Target {
54043        &self.inner
54044    }
54045}
54046impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54047    fn deref_mut(&mut self) -> &mut Self::Target {
54048        &mut self.inner
54049    }
54050}
54051impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
54052    pub fn integer_dot_product8_bit_unsigned_accelerated(
54053        mut self,
54054        integer_dot_product8_bit_unsigned_accelerated: bool,
54055    ) -> Self {
54056        self.inner.integer_dot_product8_bit_unsigned_accelerated =
54057            integer_dot_product8_bit_unsigned_accelerated.into();
54058        self
54059    }
54060    pub fn integer_dot_product8_bit_signed_accelerated(
54061        mut self,
54062        integer_dot_product8_bit_signed_accelerated: bool,
54063    ) -> Self {
54064        self.inner.integer_dot_product8_bit_signed_accelerated =
54065            integer_dot_product8_bit_signed_accelerated.into();
54066        self
54067    }
54068    pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
54069        mut self,
54070        integer_dot_product8_bit_mixed_signedness_accelerated: bool,
54071    ) -> Self {
54072        self.inner
54073            .integer_dot_product8_bit_mixed_signedness_accelerated =
54074            integer_dot_product8_bit_mixed_signedness_accelerated.into();
54075        self
54076    }
54077    pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
54078        mut self,
54079        integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
54080    ) -> Self {
54081        self.inner
54082            .integer_dot_product4x8_bit_packed_unsigned_accelerated =
54083            integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
54084        self
54085    }
54086    pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
54087        mut self,
54088        integer_dot_product4x8_bit_packed_signed_accelerated: bool,
54089    ) -> Self {
54090        self.inner
54091            .integer_dot_product4x8_bit_packed_signed_accelerated =
54092            integer_dot_product4x8_bit_packed_signed_accelerated.into();
54093        self
54094    }
54095    pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
54096        mut self,
54097        integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
54098    ) -> Self {
54099        self.inner
54100            .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated =
54101            integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
54102        self
54103    }
54104    pub fn integer_dot_product16_bit_unsigned_accelerated(
54105        mut self,
54106        integer_dot_product16_bit_unsigned_accelerated: bool,
54107    ) -> Self {
54108        self.inner.integer_dot_product16_bit_unsigned_accelerated =
54109            integer_dot_product16_bit_unsigned_accelerated.into();
54110        self
54111    }
54112    pub fn integer_dot_product16_bit_signed_accelerated(
54113        mut self,
54114        integer_dot_product16_bit_signed_accelerated: bool,
54115    ) -> Self {
54116        self.inner.integer_dot_product16_bit_signed_accelerated =
54117            integer_dot_product16_bit_signed_accelerated.into();
54118        self
54119    }
54120    pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
54121        mut self,
54122        integer_dot_product16_bit_mixed_signedness_accelerated: bool,
54123    ) -> Self {
54124        self.inner
54125            .integer_dot_product16_bit_mixed_signedness_accelerated =
54126            integer_dot_product16_bit_mixed_signedness_accelerated.into();
54127        self
54128    }
54129    pub fn integer_dot_product32_bit_unsigned_accelerated(
54130        mut self,
54131        integer_dot_product32_bit_unsigned_accelerated: bool,
54132    ) -> Self {
54133        self.inner.integer_dot_product32_bit_unsigned_accelerated =
54134            integer_dot_product32_bit_unsigned_accelerated.into();
54135        self
54136    }
54137    pub fn integer_dot_product32_bit_signed_accelerated(
54138        mut self,
54139        integer_dot_product32_bit_signed_accelerated: bool,
54140    ) -> Self {
54141        self.inner.integer_dot_product32_bit_signed_accelerated =
54142            integer_dot_product32_bit_signed_accelerated.into();
54143        self
54144    }
54145    pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
54146        mut self,
54147        integer_dot_product32_bit_mixed_signedness_accelerated: bool,
54148    ) -> Self {
54149        self.inner
54150            .integer_dot_product32_bit_mixed_signedness_accelerated =
54151            integer_dot_product32_bit_mixed_signedness_accelerated.into();
54152        self
54153    }
54154    pub fn integer_dot_product64_bit_unsigned_accelerated(
54155        mut self,
54156        integer_dot_product64_bit_unsigned_accelerated: bool,
54157    ) -> Self {
54158        self.inner.integer_dot_product64_bit_unsigned_accelerated =
54159            integer_dot_product64_bit_unsigned_accelerated.into();
54160        self
54161    }
54162    pub fn integer_dot_product64_bit_signed_accelerated(
54163        mut self,
54164        integer_dot_product64_bit_signed_accelerated: bool,
54165    ) -> Self {
54166        self.inner.integer_dot_product64_bit_signed_accelerated =
54167            integer_dot_product64_bit_signed_accelerated.into();
54168        self
54169    }
54170    pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
54171        mut self,
54172        integer_dot_product64_bit_mixed_signedness_accelerated: bool,
54173    ) -> Self {
54174        self.inner
54175            .integer_dot_product64_bit_mixed_signedness_accelerated =
54176            integer_dot_product64_bit_mixed_signedness_accelerated.into();
54177        self
54178    }
54179    pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
54180        mut self,
54181        integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
54182    ) -> Self {
54183        self.inner
54184            .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated =
54185            integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
54186        self
54187    }
54188    pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
54189        mut self,
54190        integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
54191    ) -> Self {
54192        self.inner
54193            .integer_dot_product_accumulating_saturating8_bit_signed_accelerated =
54194            integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
54195        self
54196    }
54197    pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
54198        mut self,
54199        integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
54200    ) -> Self {
54201        self.inner
54202            .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated =
54203            integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
54204        self
54205    }
54206    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
54207        mut self,
54208        integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
54209    ) -> Self {
54210        self.inner
54211            .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated =
54212            integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
54213        self
54214    }
54215    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
54216        mut self,
54217        integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
54218    ) -> Self {
54219        self.inner
54220            .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated =
54221            integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
54222        self
54223    }
54224    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
54225        mut self,
54226        integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
54227    ) -> Self {
54228        self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
54229        self
54230    }
54231    pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
54232        mut self,
54233        integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
54234    ) -> Self {
54235        self.inner
54236            .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated =
54237            integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
54238        self
54239    }
54240    pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
54241        mut self,
54242        integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
54243    ) -> Self {
54244        self.inner
54245            .integer_dot_product_accumulating_saturating16_bit_signed_accelerated =
54246            integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
54247        self
54248    }
54249    pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
54250        mut self,
54251        integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
54252    ) -> Self {
54253        self.inner
54254            .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated =
54255            integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
54256        self
54257    }
54258    pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
54259        mut self,
54260        integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
54261    ) -> Self {
54262        self.inner
54263            .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated =
54264            integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
54265        self
54266    }
54267    pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
54268        mut self,
54269        integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
54270    ) -> Self {
54271        self.inner
54272            .integer_dot_product_accumulating_saturating32_bit_signed_accelerated =
54273            integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
54274        self
54275    }
54276    pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
54277        mut self,
54278        integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
54279    ) -> Self {
54280        self.inner
54281            .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated =
54282            integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
54283        self
54284    }
54285    pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
54286        mut self,
54287        integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
54288    ) -> Self {
54289        self.inner
54290            .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated =
54291            integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
54292        self
54293    }
54294    pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
54295        mut self,
54296        integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
54297    ) -> Self {
54298        self.inner
54299            .integer_dot_product_accumulating_saturating64_bit_signed_accelerated =
54300            integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
54301        self
54302    }
54303    pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
54304        mut self,
54305        integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
54306    ) -> Self {
54307        self.inner
54308            .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated =
54309            integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into();
54310        self
54311    }
54312    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54313    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54314    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54315    pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductProperties {
54316        self.inner
54317    }
54318}
54319#[repr(C)]
54320#[cfg_attr(feature = "debug", derive(Debug))]
54321#[derive(Copy, Clone)]
54322#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html>"]
54323pub struct PhysicalDeviceDrmPropertiesEXT {
54324    pub s_type: StructureType,
54325    pub p_next: *mut c_void,
54326    pub has_primary: Bool32,
54327    pub has_render: Bool32,
54328    pub primary_major: i64,
54329    pub primary_minor: i64,
54330    pub render_major: i64,
54331    pub render_minor: i64,
54332}
54333impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT {
54334    fn default() -> Self {
54335        Self {
54336            s_type: StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT,
54337            p_next: ::std::ptr::null_mut(),
54338            has_primary: Bool32::default(),
54339            has_render: Bool32::default(),
54340            primary_major: i64::default(),
54341            primary_minor: i64::default(),
54342            render_major: i64::default(),
54343            render_minor: i64::default(),
54344        }
54345    }
54346}
54347impl PhysicalDeviceDrmPropertiesEXT {
54348    pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54349        PhysicalDeviceDrmPropertiesEXTBuilder {
54350            inner: Self::default(),
54351            marker: ::std::marker::PhantomData,
54352        }
54353    }
54354}
54355#[repr(transparent)]
54356pub struct PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54357    inner: PhysicalDeviceDrmPropertiesEXT,
54358    marker: ::std::marker::PhantomData<&'a ()>,
54359}
54360unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXTBuilder<'_> {}
54361unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT {}
54362impl<'a> ::std::ops::Deref for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54363    type Target = PhysicalDeviceDrmPropertiesEXT;
54364    fn deref(&self) -> &Self::Target {
54365        &self.inner
54366    }
54367}
54368impl<'a> ::std::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54369    fn deref_mut(&mut self) -> &mut Self::Target {
54370        &mut self.inner
54371    }
54372}
54373impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
54374    pub fn has_primary(mut self, has_primary: bool) -> Self {
54375        self.inner.has_primary = has_primary.into();
54376        self
54377    }
54378    pub fn has_render(mut self, has_render: bool) -> Self {
54379        self.inner.has_render = has_render.into();
54380        self
54381    }
54382    pub fn primary_major(mut self, primary_major: i64) -> Self {
54383        self.inner.primary_major = primary_major;
54384        self
54385    }
54386    pub fn primary_minor(mut self, primary_minor: i64) -> Self {
54387        self.inner.primary_minor = primary_minor;
54388        self
54389    }
54390    pub fn render_major(mut self, render_major: i64) -> Self {
54391        self.inner.render_major = render_major;
54392        self
54393    }
54394    pub fn render_minor(mut self, render_minor: i64) -> Self {
54395        self.inner.render_minor = render_minor;
54396        self
54397    }
54398    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54399    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54400    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54401    pub fn build(self) -> PhysicalDeviceDrmPropertiesEXT {
54402        self.inner
54403    }
54404}
54405#[repr(C)]
54406#[cfg_attr(feature = "debug", derive(Debug))]
54407#[derive(Copy, Clone)]
54408#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html>"]
54409pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54410    pub s_type: StructureType,
54411    pub p_next: *mut c_void,
54412    pub ray_tracing_motion_blur: Bool32,
54413    pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32,
54414}
54415impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54416    fn default() -> Self {
54417        Self {
54418            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV,
54419            p_next: ::std::ptr::null_mut(),
54420            ray_tracing_motion_blur: Bool32::default(),
54421            ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(),
54422        }
54423    }
54424}
54425impl PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54426    pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54427        PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder {
54428            inner: Self::default(),
54429            marker: ::std::marker::PhantomData,
54430        }
54431    }
54432}
54433#[repr(transparent)]
54434pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54435    inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV,
54436    marker: ::std::marker::PhantomData<&'a ()>,
54437}
54438unsafe impl ExtendsPhysicalDeviceFeatures2
54439    for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_>
54440{
54441}
54442unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV {}
54443unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> {}
54444unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV {}
54445impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54446    type Target = PhysicalDeviceRayTracingMotionBlurFeaturesNV;
54447    fn deref(&self) -> &Self::Target {
54448        &self.inner
54449    }
54450}
54451impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54452    fn deref_mut(&mut self) -> &mut Self::Target {
54453        &mut self.inner
54454    }
54455}
54456impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
54457    pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self {
54458        self.inner.ray_tracing_motion_blur = ray_tracing_motion_blur.into();
54459        self
54460    }
54461    pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect(
54462        mut self,
54463        ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool,
54464    ) -> Self {
54465        self.inner
54466            .ray_tracing_motion_blur_pipeline_trace_rays_indirect =
54467            ray_tracing_motion_blur_pipeline_trace_rays_indirect.into();
54468        self
54469    }
54470    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54471    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54472    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54473    pub fn build(self) -> PhysicalDeviceRayTracingMotionBlurFeaturesNV {
54474        self.inner
54475    }
54476}
54477#[repr(C)]
54478#[derive(Copy, Clone)]
54479#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html>"]
54480pub struct AccelerationStructureGeometryMotionTrianglesDataNV {
54481    pub s_type: StructureType,
54482    pub p_next: *const c_void,
54483    pub vertex_data: DeviceOrHostAddressConstKHR,
54484}
54485#[cfg(feature = "debug")]
54486impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV {
54487    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
54488        fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV")
54489            .field("s_type", &self.s_type)
54490            .field("p_next", &self.p_next)
54491            .field("vertex_data", &"union")
54492            .finish()
54493    }
54494}
54495impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV {
54496    fn default() -> Self {
54497        Self {
54498            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV,
54499            p_next: ::std::ptr::null(),
54500            vertex_data: DeviceOrHostAddressConstKHR::default(),
54501        }
54502    }
54503}
54504impl AccelerationStructureGeometryMotionTrianglesDataNV {
54505    pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54506        AccelerationStructureGeometryMotionTrianglesDataNVBuilder {
54507            inner: Self::default(),
54508            marker: ::std::marker::PhantomData,
54509        }
54510    }
54511}
54512#[repr(transparent)]
54513pub struct AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54514    inner: AccelerationStructureGeometryMotionTrianglesDataNV,
54515    marker: ::std::marker::PhantomData<&'a ()>,
54516}
54517unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
54518    for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'_>
54519{
54520}
54521unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
54522    for AccelerationStructureGeometryMotionTrianglesDataNV
54523{
54524}
54525impl<'a> ::std::ops::Deref for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54526    type Target = AccelerationStructureGeometryMotionTrianglesDataNV;
54527    fn deref(&self) -> &Self::Target {
54528        &self.inner
54529    }
54530}
54531impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54532    fn deref_mut(&mut self) -> &mut Self::Target {
54533        &mut self.inner
54534    }
54535}
54536impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
54537    pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
54538        self.inner.vertex_data = vertex_data;
54539        self
54540    }
54541    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54542    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54543    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54544    pub fn build(self) -> AccelerationStructureGeometryMotionTrianglesDataNV {
54545        self.inner
54546    }
54547}
54548#[repr(C)]
54549#[cfg_attr(feature = "debug", derive(Debug))]
54550#[derive(Copy, Clone)]
54551#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoNV.html>"]
54552pub struct AccelerationStructureMotionInfoNV {
54553    pub s_type: StructureType,
54554    pub p_next: *const c_void,
54555    pub max_instances: u32,
54556    pub flags: AccelerationStructureMotionInfoFlagsNV,
54557}
54558impl ::std::default::Default for AccelerationStructureMotionInfoNV {
54559    fn default() -> Self {
54560        Self {
54561            s_type: StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV,
54562            p_next: ::std::ptr::null(),
54563            max_instances: u32::default(),
54564            flags: AccelerationStructureMotionInfoFlagsNV::default(),
54565        }
54566    }
54567}
54568impl AccelerationStructureMotionInfoNV {
54569    pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> {
54570        AccelerationStructureMotionInfoNVBuilder {
54571            inner: Self::default(),
54572            marker: ::std::marker::PhantomData,
54573        }
54574    }
54575}
54576#[repr(transparent)]
54577pub struct AccelerationStructureMotionInfoNVBuilder<'a> {
54578    inner: AccelerationStructureMotionInfoNV,
54579    marker: ::std::marker::PhantomData<&'a ()>,
54580}
54581unsafe impl ExtendsAccelerationStructureCreateInfoKHR
54582    for AccelerationStructureMotionInfoNVBuilder<'_>
54583{
54584}
54585unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV {}
54586impl<'a> ::std::ops::Deref for AccelerationStructureMotionInfoNVBuilder<'a> {
54587    type Target = AccelerationStructureMotionInfoNV;
54588    fn deref(&self) -> &Self::Target {
54589        &self.inner
54590    }
54591}
54592impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> {
54593    fn deref_mut(&mut self) -> &mut Self::Target {
54594        &mut self.inner
54595    }
54596}
54597impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> {
54598    pub fn max_instances(mut self, max_instances: u32) -> Self {
54599        self.inner.max_instances = max_instances;
54600        self
54601    }
54602    pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self {
54603        self.inner.flags = flags;
54604        self
54605    }
54606    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54607    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54608    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54609    pub fn build(self) -> AccelerationStructureMotionInfoNV {
54610        self.inner
54611    }
54612}
54613#[repr(C)]
54614#[cfg_attr(feature = "debug", derive(Debug))]
54615#[derive(Copy, Clone, Default)]
54616#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSRTDataNV.html>"]
54617pub struct SRTDataNV {
54618    pub sx: f32,
54619    pub a: f32,
54620    pub b: f32,
54621    pub pvx: f32,
54622    pub sy: f32,
54623    pub c: f32,
54624    pub pvy: f32,
54625    pub sz: f32,
54626    pub pvz: f32,
54627    pub qx: f32,
54628    pub qy: f32,
54629    pub qz: f32,
54630    pub qw: f32,
54631    pub tx: f32,
54632    pub ty: f32,
54633    pub tz: f32,
54634}
54635impl SRTDataNV {
54636    pub fn builder<'a>() -> SRTDataNVBuilder<'a> {
54637        SRTDataNVBuilder {
54638            inner: Self::default(),
54639            marker: ::std::marker::PhantomData,
54640        }
54641    }
54642}
54643#[repr(transparent)]
54644pub struct SRTDataNVBuilder<'a> {
54645    inner: SRTDataNV,
54646    marker: ::std::marker::PhantomData<&'a ()>,
54647}
54648impl<'a> ::std::ops::Deref for SRTDataNVBuilder<'a> {
54649    type Target = SRTDataNV;
54650    fn deref(&self) -> &Self::Target {
54651        &self.inner
54652    }
54653}
54654impl<'a> ::std::ops::DerefMut for SRTDataNVBuilder<'a> {
54655    fn deref_mut(&mut self) -> &mut Self::Target {
54656        &mut self.inner
54657    }
54658}
54659impl<'a> SRTDataNVBuilder<'a> {
54660    pub fn sx(mut self, sx: f32) -> Self {
54661        self.inner.sx = sx;
54662        self
54663    }
54664    pub fn a(mut self, a: f32) -> Self {
54665        self.inner.a = a;
54666        self
54667    }
54668    pub fn b(mut self, b: f32) -> Self {
54669        self.inner.b = b;
54670        self
54671    }
54672    pub fn pvx(mut self, pvx: f32) -> Self {
54673        self.inner.pvx = pvx;
54674        self
54675    }
54676    pub fn sy(mut self, sy: f32) -> Self {
54677        self.inner.sy = sy;
54678        self
54679    }
54680    pub fn c(mut self, c: f32) -> Self {
54681        self.inner.c = c;
54682        self
54683    }
54684    pub fn pvy(mut self, pvy: f32) -> Self {
54685        self.inner.pvy = pvy;
54686        self
54687    }
54688    pub fn sz(mut self, sz: f32) -> Self {
54689        self.inner.sz = sz;
54690        self
54691    }
54692    pub fn pvz(mut self, pvz: f32) -> Self {
54693        self.inner.pvz = pvz;
54694        self
54695    }
54696    pub fn qx(mut self, qx: f32) -> Self {
54697        self.inner.qx = qx;
54698        self
54699    }
54700    pub fn qy(mut self, qy: f32) -> Self {
54701        self.inner.qy = qy;
54702        self
54703    }
54704    pub fn qz(mut self, qz: f32) -> Self {
54705        self.inner.qz = qz;
54706        self
54707    }
54708    pub fn qw(mut self, qw: f32) -> Self {
54709        self.inner.qw = qw;
54710        self
54711    }
54712    pub fn tx(mut self, tx: f32) -> Self {
54713        self.inner.tx = tx;
54714        self
54715    }
54716    pub fn ty(mut self, ty: f32) -> Self {
54717        self.inner.ty = ty;
54718        self
54719    }
54720    pub fn tz(mut self, tz: f32) -> Self {
54721        self.inner.tz = tz;
54722        self
54723    }
54724    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54725    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54726    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54727    pub fn build(self) -> SRTDataNV {
54728        self.inner
54729    }
54730}
54731#[repr(C)]
54732#[derive(Copy, Clone)]
54733#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureSRTMotionInstanceNV.html>"]
54734pub struct AccelerationStructureSRTMotionInstanceNV {
54735    pub transform_t0: SRTDataNV,
54736    pub transform_t1: SRTDataNV,
54737    #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
54738    pub instance_custom_index_and_mask: Packed24_8,
54739    #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
54740    pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
54741    pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
54742}
54743#[repr(C)]
54744#[derive(Copy, Clone)]
54745#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/AccelerationStructureMatrixMotionInstanceNV.html>"]
54746pub struct AccelerationStructureMatrixMotionInstanceNV {
54747    pub transform_t0: TransformMatrixKHR,
54748    pub transform_t1: TransformMatrixKHR,
54749    #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
54750    pub instance_custom_index_and_mask: Packed24_8,
54751    #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
54752    pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
54753    pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
54754}
54755#[repr(C)]
54756#[derive(Copy, Clone)]
54757#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceDataNV.html>"]
54758pub union AccelerationStructureMotionInstanceDataNV {
54759    pub static_instance: AccelerationStructureInstanceKHR,
54760    pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV,
54761    pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV,
54762}
54763impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV {
54764    fn default() -> Self {
54765        unsafe { ::std::mem::zeroed() }
54766    }
54767}
54768#[repr(C)]
54769#[derive(Copy, Clone, Default)]
54770#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceNV.html>"]
54771pub struct AccelerationStructureMotionInstanceNV {
54772    pub ty: AccelerationStructureMotionInstanceTypeNV,
54773    pub flags: AccelerationStructureMotionInstanceFlagsNV,
54774    pub data: AccelerationStructureMotionInstanceDataNV,
54775}
54776#[cfg(feature = "debug")]
54777impl fmt::Debug for AccelerationStructureMotionInstanceNV {
54778    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
54779        fmt.debug_struct("AccelerationStructureMotionInstanceNV")
54780            .field("ty", &self.ty)
54781            .field("flags", &self.flags)
54782            .field("data", &"union")
54783            .finish()
54784    }
54785}
54786impl AccelerationStructureMotionInstanceNV {
54787    pub fn builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a> {
54788        AccelerationStructureMotionInstanceNVBuilder {
54789            inner: Self::default(),
54790            marker: ::std::marker::PhantomData,
54791        }
54792    }
54793}
54794#[repr(transparent)]
54795pub struct AccelerationStructureMotionInstanceNVBuilder<'a> {
54796    inner: AccelerationStructureMotionInstanceNV,
54797    marker: ::std::marker::PhantomData<&'a ()>,
54798}
54799impl<'a> ::std::ops::Deref for AccelerationStructureMotionInstanceNVBuilder<'a> {
54800    type Target = AccelerationStructureMotionInstanceNV;
54801    fn deref(&self) -> &Self::Target {
54802        &self.inner
54803    }
54804}
54805impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder<'a> {
54806    fn deref_mut(&mut self) -> &mut Self::Target {
54807        &mut self.inner
54808    }
54809}
54810impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> {
54811    pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self {
54812        self.inner.ty = ty;
54813        self
54814    }
54815    pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self {
54816        self.inner.flags = flags;
54817        self
54818    }
54819    pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self {
54820        self.inner.data = data;
54821        self
54822    }
54823    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54824    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54825    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54826    pub fn build(self) -> AccelerationStructureMotionInstanceNV {
54827        self.inner
54828    }
54829}
54830#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRemoteAddressNV.html>"]
54831pub type RemoteAddressNV = c_void;
54832#[repr(C)]
54833#[cfg_attr(feature = "debug", derive(Debug))]
54834#[derive(Copy, Clone)]
54835#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetRemoteAddressInfoNV.html>"]
54836pub struct MemoryGetRemoteAddressInfoNV {
54837    pub s_type: StructureType,
54838    pub p_next: *const c_void,
54839    pub memory: DeviceMemory,
54840    pub handle_type: ExternalMemoryHandleTypeFlags,
54841}
54842impl ::std::default::Default for MemoryGetRemoteAddressInfoNV {
54843    fn default() -> Self {
54844        Self {
54845            s_type: StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV,
54846            p_next: ::std::ptr::null(),
54847            memory: DeviceMemory::default(),
54848            handle_type: ExternalMemoryHandleTypeFlags::default(),
54849        }
54850    }
54851}
54852impl MemoryGetRemoteAddressInfoNV {
54853    pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> {
54854        MemoryGetRemoteAddressInfoNVBuilder {
54855            inner: Self::default(),
54856            marker: ::std::marker::PhantomData,
54857        }
54858    }
54859}
54860#[repr(transparent)]
54861pub struct MemoryGetRemoteAddressInfoNVBuilder<'a> {
54862    inner: MemoryGetRemoteAddressInfoNV,
54863    marker: ::std::marker::PhantomData<&'a ()>,
54864}
54865impl<'a> ::std::ops::Deref for MemoryGetRemoteAddressInfoNVBuilder<'a> {
54866    type Target = MemoryGetRemoteAddressInfoNV;
54867    fn deref(&self) -> &Self::Target {
54868        &self.inner
54869    }
54870}
54871impl<'a> ::std::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> {
54872    fn deref_mut(&mut self) -> &mut Self::Target {
54873        &mut self.inner
54874    }
54875}
54876impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> {
54877    pub fn memory(mut self, memory: DeviceMemory) -> Self {
54878        self.inner.memory = memory;
54879        self
54880    }
54881    pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
54882        self.inner.handle_type = handle_type;
54883        self
54884    }
54885    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54886    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54887    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54888    pub fn build(self) -> MemoryGetRemoteAddressInfoNV {
54889        self.inner
54890    }
54891}
54892#[repr(C)]
54893#[cfg_attr(feature = "debug", derive(Debug))]
54894#[derive(Copy, Clone)]
54895#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryBufferCollectionFUCHSIA.html>"]
54896pub struct ImportMemoryBufferCollectionFUCHSIA {
54897    pub s_type: StructureType,
54898    pub p_next: *const c_void,
54899    pub collection: BufferCollectionFUCHSIA,
54900    pub index: u32,
54901}
54902impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA {
54903    fn default() -> Self {
54904        Self {
54905            s_type: StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
54906            p_next: ::std::ptr::null(),
54907            collection: BufferCollectionFUCHSIA::default(),
54908            index: u32::default(),
54909        }
54910    }
54911}
54912impl ImportMemoryBufferCollectionFUCHSIA {
54913    pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54914        ImportMemoryBufferCollectionFUCHSIABuilder {
54915            inner: Self::default(),
54916            marker: ::std::marker::PhantomData,
54917        }
54918    }
54919}
54920#[repr(transparent)]
54921pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54922    inner: ImportMemoryBufferCollectionFUCHSIA,
54923    marker: ::std::marker::PhantomData<&'a ()>,
54924}
54925unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {}
54926unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {}
54927impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54928    type Target = ImportMemoryBufferCollectionFUCHSIA;
54929    fn deref(&self) -> &Self::Target {
54930        &self.inner
54931    }
54932}
54933impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54934    fn deref_mut(&mut self) -> &mut Self::Target {
54935        &mut self.inner
54936    }
54937}
54938impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
54939    pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
54940        self.inner.collection = collection;
54941        self
54942    }
54943    pub fn index(mut self, index: u32) -> Self {
54944        self.inner.index = index;
54945        self
54946    }
54947    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
54948    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
54949    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
54950    pub fn build(self) -> ImportMemoryBufferCollectionFUCHSIA {
54951        self.inner
54952    }
54953}
54954#[repr(C)]
54955#[cfg_attr(feature = "debug", derive(Debug))]
54956#[derive(Copy, Clone)]
54957#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html>"]
54958pub struct BufferCollectionImageCreateInfoFUCHSIA {
54959    pub s_type: StructureType,
54960    pub p_next: *const c_void,
54961    pub collection: BufferCollectionFUCHSIA,
54962    pub index: u32,
54963}
54964impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA {
54965    fn default() -> Self {
54966        Self {
54967            s_type: StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
54968            p_next: ::std::ptr::null(),
54969            collection: BufferCollectionFUCHSIA::default(),
54970            index: u32::default(),
54971        }
54972    }
54973}
54974impl BufferCollectionImageCreateInfoFUCHSIA {
54975    pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54976        BufferCollectionImageCreateInfoFUCHSIABuilder {
54977            inner: Self::default(),
54978            marker: ::std::marker::PhantomData,
54979        }
54980    }
54981}
54982#[repr(transparent)]
54983pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54984    inner: BufferCollectionImageCreateInfoFUCHSIA,
54985    marker: ::std::marker::PhantomData<&'a ()>,
54986}
54987unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {}
54988unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {}
54989impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54990    type Target = BufferCollectionImageCreateInfoFUCHSIA;
54991    fn deref(&self) -> &Self::Target {
54992        &self.inner
54993    }
54994}
54995impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
54996    fn deref_mut(&mut self) -> &mut Self::Target {
54997        &mut self.inner
54998    }
54999}
55000impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
55001    pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
55002        self.inner.collection = collection;
55003        self
55004    }
55005    pub fn index(mut self, index: u32) -> Self {
55006        self.inner.index = index;
55007        self
55008    }
55009    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55010    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55011    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55012    pub fn build(self) -> BufferCollectionImageCreateInfoFUCHSIA {
55013        self.inner
55014    }
55015}
55016#[repr(C)]
55017#[cfg_attr(feature = "debug", derive(Debug))]
55018#[derive(Copy, Clone)]
55019#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html>"]
55020pub struct BufferCollectionBufferCreateInfoFUCHSIA {
55021    pub s_type: StructureType,
55022    pub p_next: *const c_void,
55023    pub collection: BufferCollectionFUCHSIA,
55024    pub index: u32,
55025}
55026impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA {
55027    fn default() -> Self {
55028        Self {
55029            s_type: StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA,
55030            p_next: ::std::ptr::null(),
55031            collection: BufferCollectionFUCHSIA::default(),
55032            index: u32::default(),
55033        }
55034    }
55035}
55036impl BufferCollectionBufferCreateInfoFUCHSIA {
55037    pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55038        BufferCollectionBufferCreateInfoFUCHSIABuilder {
55039            inner: Self::default(),
55040            marker: ::std::marker::PhantomData,
55041        }
55042    }
55043}
55044#[repr(transparent)]
55045pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55046    inner: BufferCollectionBufferCreateInfoFUCHSIA,
55047    marker: ::std::marker::PhantomData<&'a ()>,
55048}
55049unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {}
55050unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {}
55051impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55052    type Target = BufferCollectionBufferCreateInfoFUCHSIA;
55053    fn deref(&self) -> &Self::Target {
55054        &self.inner
55055    }
55056}
55057impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55058    fn deref_mut(&mut self) -> &mut Self::Target {
55059        &mut self.inner
55060    }
55061}
55062impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
55063    pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
55064        self.inner.collection = collection;
55065        self
55066    }
55067    pub fn index(mut self, index: u32) -> Self {
55068        self.inner.index = index;
55069        self
55070    }
55071    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55072    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55073    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55074    pub fn build(self) -> BufferCollectionBufferCreateInfoFUCHSIA {
55075        self.inner
55076    }
55077}
55078#[repr(C)]
55079#[cfg_attr(feature = "debug", derive(Debug))]
55080#[derive(Copy, Clone)]
55081#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionCreateInfoFUCHSIA.html>"]
55082pub struct BufferCollectionCreateInfoFUCHSIA {
55083    pub s_type: StructureType,
55084    pub p_next: *const c_void,
55085    pub collection_token: zx_handle_t,
55086}
55087impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA {
55088    fn default() -> Self {
55089        Self {
55090            s_type: StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
55091            p_next: ::std::ptr::null(),
55092            collection_token: zx_handle_t::default(),
55093        }
55094    }
55095}
55096impl BufferCollectionCreateInfoFUCHSIA {
55097    pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55098        BufferCollectionCreateInfoFUCHSIABuilder {
55099            inner: Self::default(),
55100            marker: ::std::marker::PhantomData,
55101        }
55102    }
55103}
55104#[repr(transparent)]
55105pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55106    inner: BufferCollectionCreateInfoFUCHSIA,
55107    marker: ::std::marker::PhantomData<&'a ()>,
55108}
55109impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55110    type Target = BufferCollectionCreateInfoFUCHSIA;
55111    fn deref(&self) -> &Self::Target {
55112        &self.inner
55113    }
55114}
55115impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55116    fn deref_mut(&mut self) -> &mut Self::Target {
55117        &mut self.inner
55118    }
55119}
55120impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
55121    pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self {
55122        self.inner.collection_token = collection_token;
55123        self
55124    }
55125    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55126    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55127    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55128    pub fn build(self) -> BufferCollectionCreateInfoFUCHSIA {
55129        self.inner
55130    }
55131}
55132#[repr(C)]
55133#[cfg_attr(feature = "debug", derive(Debug))]
55134#[derive(Copy, Clone)]
55135#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionPropertiesFUCHSIA.html>"]
55136pub struct BufferCollectionPropertiesFUCHSIA {
55137    pub s_type: StructureType,
55138    pub p_next: *mut c_void,
55139    pub memory_type_bits: u32,
55140    pub buffer_count: u32,
55141    pub create_info_index: u32,
55142    pub sysmem_pixel_format: u64,
55143    pub format_features: FormatFeatureFlags,
55144    pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
55145    pub sampler_ycbcr_conversion_components: ComponentMapping,
55146    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
55147    pub suggested_ycbcr_range: SamplerYcbcrRange,
55148    pub suggested_x_chroma_offset: ChromaLocation,
55149    pub suggested_y_chroma_offset: ChromaLocation,
55150}
55151impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA {
55152    fn default() -> Self {
55153        Self {
55154            s_type: StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA,
55155            p_next: ::std::ptr::null_mut(),
55156            memory_type_bits: u32::default(),
55157            buffer_count: u32::default(),
55158            create_info_index: u32::default(),
55159            sysmem_pixel_format: u64::default(),
55160            format_features: FormatFeatureFlags::default(),
55161            sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(),
55162            sampler_ycbcr_conversion_components: ComponentMapping::default(),
55163            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
55164            suggested_ycbcr_range: SamplerYcbcrRange::default(),
55165            suggested_x_chroma_offset: ChromaLocation::default(),
55166            suggested_y_chroma_offset: ChromaLocation::default(),
55167        }
55168    }
55169}
55170impl BufferCollectionPropertiesFUCHSIA {
55171    pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> {
55172        BufferCollectionPropertiesFUCHSIABuilder {
55173            inner: Self::default(),
55174            marker: ::std::marker::PhantomData,
55175        }
55176    }
55177}
55178#[repr(transparent)]
55179pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> {
55180    inner: BufferCollectionPropertiesFUCHSIA,
55181    marker: ::std::marker::PhantomData<&'a ()>,
55182}
55183impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> {
55184    type Target = BufferCollectionPropertiesFUCHSIA;
55185    fn deref(&self) -> &Self::Target {
55186        &self.inner
55187    }
55188}
55189impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> {
55190    fn deref_mut(&mut self) -> &mut Self::Target {
55191        &mut self.inner
55192    }
55193}
55194impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> {
55195    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
55196        self.inner.memory_type_bits = memory_type_bits;
55197        self
55198    }
55199    pub fn buffer_count(mut self, buffer_count: u32) -> Self {
55200        self.inner.buffer_count = buffer_count;
55201        self
55202    }
55203    pub fn create_info_index(mut self, create_info_index: u32) -> Self {
55204        self.inner.create_info_index = create_info_index;
55205        self
55206    }
55207    pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
55208        self.inner.sysmem_pixel_format = sysmem_pixel_format;
55209        self
55210    }
55211    pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
55212        self.inner.format_features = format_features;
55213        self
55214    }
55215    pub fn sysmem_color_space_index(
55216        mut self,
55217        sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
55218    ) -> Self {
55219        self.inner.sysmem_color_space_index = sysmem_color_space_index;
55220        self
55221    }
55222    pub fn sampler_ycbcr_conversion_components(
55223        mut self,
55224        sampler_ycbcr_conversion_components: ComponentMapping,
55225    ) -> Self {
55226        self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
55227        self
55228    }
55229    pub fn suggested_ycbcr_model(
55230        mut self,
55231        suggested_ycbcr_model: SamplerYcbcrModelConversion,
55232    ) -> Self {
55233        self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
55234        self
55235    }
55236    pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
55237        self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
55238        self
55239    }
55240    pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
55241        self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
55242        self
55243    }
55244    pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
55245        self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
55246        self
55247    }
55248    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55249    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55250    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55251    pub fn build(self) -> BufferCollectionPropertiesFUCHSIA {
55252        self.inner
55253    }
55254}
55255#[repr(C)]
55256#[cfg_attr(feature = "debug", derive(Debug))]
55257#[derive(Copy, Clone)]
55258#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferConstraintsInfoFUCHSIA.html>"]
55259pub struct BufferConstraintsInfoFUCHSIA {
55260    pub s_type: StructureType,
55261    pub p_next: *const c_void,
55262    pub create_info: BufferCreateInfo,
55263    pub required_format_features: FormatFeatureFlags,
55264    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55265}
55266impl ::std::default::Default for BufferConstraintsInfoFUCHSIA {
55267    fn default() -> Self {
55268        Self {
55269            s_type: StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA,
55270            p_next: ::std::ptr::null(),
55271            create_info: BufferCreateInfo::default(),
55272            required_format_features: FormatFeatureFlags::default(),
55273            buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
55274        }
55275    }
55276}
55277impl BufferConstraintsInfoFUCHSIA {
55278    pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> {
55279        BufferConstraintsInfoFUCHSIABuilder {
55280            inner: Self::default(),
55281            marker: ::std::marker::PhantomData,
55282        }
55283    }
55284}
55285#[repr(transparent)]
55286pub struct BufferConstraintsInfoFUCHSIABuilder<'a> {
55287    inner: BufferConstraintsInfoFUCHSIA,
55288    marker: ::std::marker::PhantomData<&'a ()>,
55289}
55290impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> {
55291    type Target = BufferConstraintsInfoFUCHSIA;
55292    fn deref(&self) -> &Self::Target {
55293        &self.inner
55294    }
55295}
55296impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> {
55297    fn deref_mut(&mut self) -> &mut Self::Target {
55298        &mut self.inner
55299    }
55300}
55301impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> {
55302    pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self {
55303        self.inner.create_info = create_info;
55304        self
55305    }
55306    pub fn required_format_features(
55307        mut self,
55308        required_format_features: FormatFeatureFlags,
55309    ) -> Self {
55310        self.inner.required_format_features = required_format_features;
55311        self
55312    }
55313    pub fn buffer_collection_constraints(
55314        mut self,
55315        buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55316    ) -> Self {
55317        self.inner.buffer_collection_constraints = buffer_collection_constraints;
55318        self
55319    }
55320    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55321    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55322    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55323    pub fn build(self) -> BufferConstraintsInfoFUCHSIA {
55324        self.inner
55325    }
55326}
55327#[repr(C)]
55328#[cfg_attr(feature = "debug", derive(Debug))]
55329#[derive(Copy, Clone)]
55330#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSysmemColorSpaceFUCHSIA.html>"]
55331pub struct SysmemColorSpaceFUCHSIA {
55332    pub s_type: StructureType,
55333    pub p_next: *const c_void,
55334    pub color_space: u32,
55335}
55336impl ::std::default::Default for SysmemColorSpaceFUCHSIA {
55337    fn default() -> Self {
55338        Self {
55339            s_type: StructureType::SYSMEM_COLOR_SPACE_FUCHSIA,
55340            p_next: ::std::ptr::null(),
55341            color_space: u32::default(),
55342        }
55343    }
55344}
55345impl SysmemColorSpaceFUCHSIA {
55346    pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> {
55347        SysmemColorSpaceFUCHSIABuilder {
55348            inner: Self::default(),
55349            marker: ::std::marker::PhantomData,
55350        }
55351    }
55352}
55353#[repr(transparent)]
55354pub struct SysmemColorSpaceFUCHSIABuilder<'a> {
55355    inner: SysmemColorSpaceFUCHSIA,
55356    marker: ::std::marker::PhantomData<&'a ()>,
55357}
55358impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> {
55359    type Target = SysmemColorSpaceFUCHSIA;
55360    fn deref(&self) -> &Self::Target {
55361        &self.inner
55362    }
55363}
55364impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> {
55365    fn deref_mut(&mut self) -> &mut Self::Target {
55366        &mut self.inner
55367    }
55368}
55369impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> {
55370    pub fn color_space(mut self, color_space: u32) -> Self {
55371        self.inner.color_space = color_space;
55372        self
55373    }
55374    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55375    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55376    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55377    pub fn build(self) -> SysmemColorSpaceFUCHSIA {
55378        self.inner
55379    }
55380}
55381#[repr(C)]
55382#[cfg_attr(feature = "debug", derive(Debug))]
55383#[derive(Copy, Clone)]
55384#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatConstraintsInfoFUCHSIA.html>"]
55385pub struct ImageFormatConstraintsInfoFUCHSIA {
55386    pub s_type: StructureType,
55387    pub p_next: *const c_void,
55388    pub image_create_info: ImageCreateInfo,
55389    pub required_format_features: FormatFeatureFlags,
55390    pub flags: ImageFormatConstraintsFlagsFUCHSIA,
55391    pub sysmem_pixel_format: u64,
55392    pub color_space_count: u32,
55393    pub p_color_spaces: *const SysmemColorSpaceFUCHSIA,
55394}
55395impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA {
55396    fn default() -> Self {
55397        Self {
55398            s_type: StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA,
55399            p_next: ::std::ptr::null(),
55400            image_create_info: ImageCreateInfo::default(),
55401            required_format_features: FormatFeatureFlags::default(),
55402            flags: ImageFormatConstraintsFlagsFUCHSIA::default(),
55403            sysmem_pixel_format: u64::default(),
55404            color_space_count: u32::default(),
55405            p_color_spaces: ::std::ptr::null(),
55406        }
55407    }
55408}
55409impl ImageFormatConstraintsInfoFUCHSIA {
55410    pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55411        ImageFormatConstraintsInfoFUCHSIABuilder {
55412            inner: Self::default(),
55413            marker: ::std::marker::PhantomData,
55414        }
55415    }
55416}
55417#[repr(transparent)]
55418pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55419    inner: ImageFormatConstraintsInfoFUCHSIA,
55420    marker: ::std::marker::PhantomData<&'a ()>,
55421}
55422impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55423    type Target = ImageFormatConstraintsInfoFUCHSIA;
55424    fn deref(&self) -> &Self::Target {
55425        &self.inner
55426    }
55427}
55428impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55429    fn deref_mut(&mut self) -> &mut Self::Target {
55430        &mut self.inner
55431    }
55432}
55433impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
55434    pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self {
55435        self.inner.image_create_info = image_create_info;
55436        self
55437    }
55438    pub fn required_format_features(
55439        mut self,
55440        required_format_features: FormatFeatureFlags,
55441    ) -> Self {
55442        self.inner.required_format_features = required_format_features;
55443        self
55444    }
55445    pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self {
55446        self.inner.flags = flags;
55447        self
55448    }
55449    pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
55450        self.inner.sysmem_pixel_format = sysmem_pixel_format;
55451        self
55452    }
55453    pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self {
55454        self.inner.color_space_count = color_spaces.len() as _;
55455        self.inner.p_color_spaces = color_spaces.as_ptr();
55456        self
55457    }
55458    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55459    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55460    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55461    pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA {
55462        self.inner
55463    }
55464}
55465#[repr(C)]
55466#[cfg_attr(feature = "debug", derive(Debug))]
55467#[derive(Copy, Clone)]
55468#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageConstraintsInfoFUCHSIA.html>"]
55469pub struct ImageConstraintsInfoFUCHSIA {
55470    pub s_type: StructureType,
55471    pub p_next: *const c_void,
55472    pub format_constraints_count: u32,
55473    pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA,
55474    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55475    pub flags: ImageConstraintsInfoFlagsFUCHSIA,
55476}
55477impl ::std::default::Default for ImageConstraintsInfoFUCHSIA {
55478    fn default() -> Self {
55479        Self {
55480            s_type: StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA,
55481            p_next: ::std::ptr::null(),
55482            format_constraints_count: u32::default(),
55483            p_format_constraints: ::std::ptr::null(),
55484            buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
55485            flags: ImageConstraintsInfoFlagsFUCHSIA::default(),
55486        }
55487    }
55488}
55489impl ImageConstraintsInfoFUCHSIA {
55490    pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> {
55491        ImageConstraintsInfoFUCHSIABuilder {
55492            inner: Self::default(),
55493            marker: ::std::marker::PhantomData,
55494        }
55495    }
55496}
55497#[repr(transparent)]
55498pub struct ImageConstraintsInfoFUCHSIABuilder<'a> {
55499    inner: ImageConstraintsInfoFUCHSIA,
55500    marker: ::std::marker::PhantomData<&'a ()>,
55501}
55502impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> {
55503    type Target = ImageConstraintsInfoFUCHSIA;
55504    fn deref(&self) -> &Self::Target {
55505        &self.inner
55506    }
55507}
55508impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> {
55509    fn deref_mut(&mut self) -> &mut Self::Target {
55510        &mut self.inner
55511    }
55512}
55513impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> {
55514    pub fn format_constraints(
55515        mut self,
55516        format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA],
55517    ) -> Self {
55518        self.inner.format_constraints_count = format_constraints.len() as _;
55519        self.inner.p_format_constraints = format_constraints.as_ptr();
55520        self
55521    }
55522    pub fn buffer_collection_constraints(
55523        mut self,
55524        buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
55525    ) -> Self {
55526        self.inner.buffer_collection_constraints = buffer_collection_constraints;
55527        self
55528    }
55529    pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self {
55530        self.inner.flags = flags;
55531        self
55532    }
55533    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55534    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55535    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55536    pub fn build(self) -> ImageConstraintsInfoFUCHSIA {
55537        self.inner
55538    }
55539}
55540#[repr(C)]
55541#[cfg_attr(feature = "debug", derive(Debug))]
55542#[derive(Copy, Clone)]
55543#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html>"]
55544pub struct BufferCollectionConstraintsInfoFUCHSIA {
55545    pub s_type: StructureType,
55546    pub p_next: *const c_void,
55547    pub min_buffer_count: u32,
55548    pub max_buffer_count: u32,
55549    pub min_buffer_count_for_camping: u32,
55550    pub min_buffer_count_for_dedicated_slack: u32,
55551    pub min_buffer_count_for_shared_slack: u32,
55552}
55553impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA {
55554    fn default() -> Self {
55555        Self {
55556            s_type: StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA,
55557            p_next: ::std::ptr::null(),
55558            min_buffer_count: u32::default(),
55559            max_buffer_count: u32::default(),
55560            min_buffer_count_for_camping: u32::default(),
55561            min_buffer_count_for_dedicated_slack: u32::default(),
55562            min_buffer_count_for_shared_slack: u32::default(),
55563        }
55564    }
55565}
55566impl BufferCollectionConstraintsInfoFUCHSIA {
55567    pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55568        BufferCollectionConstraintsInfoFUCHSIABuilder {
55569            inner: Self::default(),
55570            marker: ::std::marker::PhantomData,
55571        }
55572    }
55573}
55574#[repr(transparent)]
55575pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55576    inner: BufferCollectionConstraintsInfoFUCHSIA,
55577    marker: ::std::marker::PhantomData<&'a ()>,
55578}
55579impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55580    type Target = BufferCollectionConstraintsInfoFUCHSIA;
55581    fn deref(&self) -> &Self::Target {
55582        &self.inner
55583    }
55584}
55585impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55586    fn deref_mut(&mut self) -> &mut Self::Target {
55587        &mut self.inner
55588    }
55589}
55590impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
55591    pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self {
55592        self.inner.min_buffer_count = min_buffer_count;
55593        self
55594    }
55595    pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self {
55596        self.inner.max_buffer_count = max_buffer_count;
55597        self
55598    }
55599    pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self {
55600        self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping;
55601        self
55602    }
55603    pub fn min_buffer_count_for_dedicated_slack(
55604        mut self,
55605        min_buffer_count_for_dedicated_slack: u32,
55606    ) -> Self {
55607        self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack;
55608        self
55609    }
55610    pub fn min_buffer_count_for_shared_slack(
55611        mut self,
55612        min_buffer_count_for_shared_slack: u32,
55613    ) -> Self {
55614        self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack;
55615        self
55616    }
55617    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55618    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55619    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55620    pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA {
55621        self.inner
55622    }
55623}
55624#[repr(C)]
55625#[cfg_attr(feature = "debug", derive(Debug))]
55626#[derive(Copy, Clone)]
55627#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html>"]
55628pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55629    pub s_type: StructureType,
55630    pub p_next: *mut c_void,
55631    pub format_rgba10x6_without_y_cb_cr_sampler: Bool32,
55632}
55633impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55634    fn default() -> Self {
55635        Self {
55636            s_type: StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT,
55637            p_next: ::std::ptr::null_mut(),
55638            format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(),
55639        }
55640    }
55641}
55642impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55643    pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55644        PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder {
55645            inner: Self::default(),
55646            marker: ::std::marker::PhantomData,
55647        }
55648    }
55649}
55650#[repr(transparent)]
55651pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55652    inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT,
55653    marker: ::std::marker::PhantomData<&'a ()>,
55654}
55655unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
55656unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
55657unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
55658unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
55659impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55660    type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
55661    fn deref(&self) -> &Self::Target {
55662        &self.inner
55663    }
55664}
55665impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55666    fn deref_mut(&mut self) -> &mut Self::Target {
55667        &mut self.inner
55668    }
55669}
55670impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
55671    pub fn format_rgba10x6_without_y_cb_cr_sampler(
55672        mut self,
55673        format_rgba10x6_without_y_cb_cr_sampler: bool,
55674    ) -> Self {
55675        self.inner.format_rgba10x6_without_y_cb_cr_sampler =
55676            format_rgba10x6_without_y_cb_cr_sampler.into();
55677        self
55678    }
55679    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55680    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55681    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55682    pub fn build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
55683        self.inner
55684    }
55685}
55686#[repr(C)]
55687#[cfg_attr(feature = "debug", derive(Debug))]
55688#[derive(Copy, Clone)]
55689#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties3.html>"]
55690pub struct FormatProperties3 {
55691    pub s_type: StructureType,
55692    pub p_next: *mut c_void,
55693    pub linear_tiling_features: FormatFeatureFlags2,
55694    pub optimal_tiling_features: FormatFeatureFlags2,
55695    pub buffer_features: FormatFeatureFlags2,
55696}
55697impl ::std::default::Default for FormatProperties3 {
55698    fn default() -> Self {
55699        Self {
55700            s_type: StructureType::FORMAT_PROPERTIES_3,
55701            p_next: ::std::ptr::null_mut(),
55702            linear_tiling_features: FormatFeatureFlags2::default(),
55703            optimal_tiling_features: FormatFeatureFlags2::default(),
55704            buffer_features: FormatFeatureFlags2::default(),
55705        }
55706    }
55707}
55708impl FormatProperties3 {
55709    pub fn builder<'a>() -> FormatProperties3Builder<'a> {
55710        FormatProperties3Builder {
55711            inner: Self::default(),
55712            marker: ::std::marker::PhantomData,
55713        }
55714    }
55715}
55716#[repr(transparent)]
55717pub struct FormatProperties3Builder<'a> {
55718    inner: FormatProperties3,
55719    marker: ::std::marker::PhantomData<&'a ()>,
55720}
55721unsafe impl ExtendsFormatProperties2 for FormatProperties3Builder<'_> {}
55722unsafe impl ExtendsFormatProperties2 for FormatProperties3 {}
55723impl<'a> ::std::ops::Deref for FormatProperties3Builder<'a> {
55724    type Target = FormatProperties3;
55725    fn deref(&self) -> &Self::Target {
55726        &self.inner
55727    }
55728}
55729impl<'a> ::std::ops::DerefMut for FormatProperties3Builder<'a> {
55730    fn deref_mut(&mut self) -> &mut Self::Target {
55731        &mut self.inner
55732    }
55733}
55734impl<'a> FormatProperties3Builder<'a> {
55735    pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self {
55736        self.inner.linear_tiling_features = linear_tiling_features;
55737        self
55738    }
55739    pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self {
55740        self.inner.optimal_tiling_features = optimal_tiling_features;
55741        self
55742    }
55743    pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self {
55744        self.inner.buffer_features = buffer_features;
55745        self
55746    }
55747    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55748    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55749    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55750    pub fn build(self) -> FormatProperties3 {
55751        self.inner
55752    }
55753}
55754#[repr(C)]
55755#[cfg_attr(feature = "debug", derive(Debug))]
55756#[derive(Copy, Clone)]
55757#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesList2EXT.html>"]
55758pub struct DrmFormatModifierPropertiesList2EXT {
55759    pub s_type: StructureType,
55760    pub p_next: *mut c_void,
55761    pub drm_format_modifier_count: u32,
55762    pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT,
55763}
55764impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT {
55765    fn default() -> Self {
55766        Self {
55767            s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT,
55768            p_next: ::std::ptr::null_mut(),
55769            drm_format_modifier_count: u32::default(),
55770            p_drm_format_modifier_properties: ::std::ptr::null_mut(),
55771        }
55772    }
55773}
55774impl DrmFormatModifierPropertiesList2EXT {
55775    pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55776        DrmFormatModifierPropertiesList2EXTBuilder {
55777            inner: Self::default(),
55778            marker: ::std::marker::PhantomData,
55779        }
55780    }
55781}
55782#[repr(transparent)]
55783pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55784    inner: DrmFormatModifierPropertiesList2EXT,
55785    marker: ::std::marker::PhantomData<&'a ()>,
55786}
55787unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {}
55788unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {}
55789impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55790    type Target = DrmFormatModifierPropertiesList2EXT;
55791    fn deref(&self) -> &Self::Target {
55792        &self.inner
55793    }
55794}
55795impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55796    fn deref_mut(&mut self) -> &mut Self::Target {
55797        &mut self.inner
55798    }
55799}
55800impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
55801    pub fn drm_format_modifier_properties(
55802        mut self,
55803        drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT],
55804    ) -> Self {
55805        self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
55806        self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
55807        self
55808    }
55809    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55810    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55811    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55812    pub fn build(self) -> DrmFormatModifierPropertiesList2EXT {
55813        self.inner
55814    }
55815}
55816#[repr(C)]
55817#[cfg_attr(feature = "debug", derive(Debug))]
55818#[derive(Copy, Clone, Default)]
55819#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierProperties2EXT.html>"]
55820pub struct DrmFormatModifierProperties2EXT {
55821    pub drm_format_modifier: u64,
55822    pub drm_format_modifier_plane_count: u32,
55823    pub drm_format_modifier_tiling_features: FormatFeatureFlags2,
55824}
55825impl DrmFormatModifierProperties2EXT {
55826    pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> {
55827        DrmFormatModifierProperties2EXTBuilder {
55828            inner: Self::default(),
55829            marker: ::std::marker::PhantomData,
55830        }
55831    }
55832}
55833#[repr(transparent)]
55834pub struct DrmFormatModifierProperties2EXTBuilder<'a> {
55835    inner: DrmFormatModifierProperties2EXT,
55836    marker: ::std::marker::PhantomData<&'a ()>,
55837}
55838impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> {
55839    type Target = DrmFormatModifierProperties2EXT;
55840    fn deref(&self) -> &Self::Target {
55841        &self.inner
55842    }
55843}
55844impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> {
55845    fn deref_mut(&mut self) -> &mut Self::Target {
55846        &mut self.inner
55847    }
55848}
55849impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> {
55850    pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
55851        self.inner.drm_format_modifier = drm_format_modifier;
55852        self
55853    }
55854    pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
55855        self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
55856        self
55857    }
55858    pub fn drm_format_modifier_tiling_features(
55859        mut self,
55860        drm_format_modifier_tiling_features: FormatFeatureFlags2,
55861    ) -> Self {
55862        self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
55863        self
55864    }
55865    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55866    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55867    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55868    pub fn build(self) -> DrmFormatModifierProperties2EXT {
55869        self.inner
55870    }
55871}
55872#[repr(C)]
55873#[cfg_attr(feature = "debug", derive(Debug))]
55874#[derive(Copy, Clone)]
55875#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html>"]
55876pub struct AndroidHardwareBufferFormatProperties2ANDROID {
55877    pub s_type: StructureType,
55878    pub p_next: *mut c_void,
55879    pub format: Format,
55880    pub external_format: u64,
55881    pub format_features: FormatFeatureFlags2,
55882    pub sampler_ycbcr_conversion_components: ComponentMapping,
55883    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
55884    pub suggested_ycbcr_range: SamplerYcbcrRange,
55885    pub suggested_x_chroma_offset: ChromaLocation,
55886    pub suggested_y_chroma_offset: ChromaLocation,
55887}
55888impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID {
55889    fn default() -> Self {
55890        Self {
55891            s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID,
55892            p_next: ::std::ptr::null_mut(),
55893            format: Format::default(),
55894            external_format: u64::default(),
55895            format_features: FormatFeatureFlags2::default(),
55896            sampler_ycbcr_conversion_components: ComponentMapping::default(),
55897            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
55898            suggested_ycbcr_range: SamplerYcbcrRange::default(),
55899            suggested_x_chroma_offset: ChromaLocation::default(),
55900            suggested_y_chroma_offset: ChromaLocation::default(),
55901        }
55902    }
55903}
55904impl AndroidHardwareBufferFormatProperties2ANDROID {
55905    pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55906        AndroidHardwareBufferFormatProperties2ANDROIDBuilder {
55907            inner: Self::default(),
55908            marker: ::std::marker::PhantomData,
55909        }
55910    }
55911}
55912#[repr(transparent)]
55913pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55914    inner: AndroidHardwareBufferFormatProperties2ANDROID,
55915    marker: ::std::marker::PhantomData<&'a ()>,
55916}
55917unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
55918    for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_>
55919{
55920}
55921unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
55922    for AndroidHardwareBufferFormatProperties2ANDROID
55923{
55924}
55925impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55926    type Target = AndroidHardwareBufferFormatProperties2ANDROID;
55927    fn deref(&self) -> &Self::Target {
55928        &self.inner
55929    }
55930}
55931impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55932    fn deref_mut(&mut self) -> &mut Self::Target {
55933        &mut self.inner
55934    }
55935}
55936impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
55937    pub fn format(mut self, format: Format) -> Self {
55938        self.inner.format = format;
55939        self
55940    }
55941    pub fn external_format(mut self, external_format: u64) -> Self {
55942        self.inner.external_format = external_format;
55943        self
55944    }
55945    pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self {
55946        self.inner.format_features = format_features;
55947        self
55948    }
55949    pub fn sampler_ycbcr_conversion_components(
55950        mut self,
55951        sampler_ycbcr_conversion_components: ComponentMapping,
55952    ) -> Self {
55953        self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
55954        self
55955    }
55956    pub fn suggested_ycbcr_model(
55957        mut self,
55958        suggested_ycbcr_model: SamplerYcbcrModelConversion,
55959    ) -> Self {
55960        self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
55961        self
55962    }
55963    pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
55964        self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
55965        self
55966    }
55967    pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
55968        self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
55969        self
55970    }
55971    pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
55972        self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
55973        self
55974    }
55975    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
55976    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
55977    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
55978    pub fn build(self) -> AndroidHardwareBufferFormatProperties2ANDROID {
55979        self.inner
55980    }
55981}
55982#[repr(C)]
55983#[cfg_attr(feature = "debug", derive(Debug))]
55984#[derive(Copy, Clone)]
55985#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRenderingCreateInfo.html>"]
55986pub struct PipelineRenderingCreateInfo {
55987    pub s_type: StructureType,
55988    pub p_next: *const c_void,
55989    pub view_mask: u32,
55990    pub color_attachment_count: u32,
55991    pub p_color_attachment_formats: *const Format,
55992    pub depth_attachment_format: Format,
55993    pub stencil_attachment_format: Format,
55994}
55995impl ::std::default::Default for PipelineRenderingCreateInfo {
55996    fn default() -> Self {
55997        Self {
55998            s_type: StructureType::PIPELINE_RENDERING_CREATE_INFO,
55999            p_next: ::std::ptr::null(),
56000            view_mask: u32::default(),
56001            color_attachment_count: u32::default(),
56002            p_color_attachment_formats: ::std::ptr::null(),
56003            depth_attachment_format: Format::default(),
56004            stencil_attachment_format: Format::default(),
56005        }
56006    }
56007}
56008impl PipelineRenderingCreateInfo {
56009    pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> {
56010        PipelineRenderingCreateInfoBuilder {
56011            inner: Self::default(),
56012            marker: ::std::marker::PhantomData,
56013        }
56014    }
56015}
56016#[repr(transparent)]
56017pub struct PipelineRenderingCreateInfoBuilder<'a> {
56018    inner: PipelineRenderingCreateInfo,
56019    marker: ::std::marker::PhantomData<&'a ()>,
56020}
56021unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoBuilder<'_> {}
56022unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo {}
56023impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> {
56024    type Target = PipelineRenderingCreateInfo;
56025    fn deref(&self) -> &Self::Target {
56026        &self.inner
56027    }
56028}
56029impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> {
56030    fn deref_mut(&mut self) -> &mut Self::Target {
56031        &mut self.inner
56032    }
56033}
56034impl<'a> PipelineRenderingCreateInfoBuilder<'a> {
56035    pub fn view_mask(mut self, view_mask: u32) -> Self {
56036        self.inner.view_mask = view_mask;
56037        self
56038    }
56039    pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
56040        self.inner.color_attachment_count = color_attachment_formats.len() as _;
56041        self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
56042        self
56043    }
56044    pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
56045        self.inner.depth_attachment_format = depth_attachment_format;
56046        self
56047    }
56048    pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
56049        self.inner.stencil_attachment_format = stencil_attachment_format;
56050        self
56051    }
56052    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56053    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56054    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56055    pub fn build(self) -> PipelineRenderingCreateInfo {
56056        self.inner
56057    }
56058}
56059#[repr(C)]
56060#[cfg_attr(feature = "debug", derive(Debug))]
56061#[derive(Copy, Clone)]
56062#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingInfo.html>"]
56063pub struct RenderingInfo {
56064    pub s_type: StructureType,
56065    pub p_next: *const c_void,
56066    pub flags: RenderingFlags,
56067    pub render_area: Rect2D,
56068    pub layer_count: u32,
56069    pub view_mask: u32,
56070    pub color_attachment_count: u32,
56071    pub p_color_attachments: *const RenderingAttachmentInfo,
56072    pub p_depth_attachment: *const RenderingAttachmentInfo,
56073    pub p_stencil_attachment: *const RenderingAttachmentInfo,
56074}
56075impl ::std::default::Default for RenderingInfo {
56076    fn default() -> Self {
56077        Self {
56078            s_type: StructureType::RENDERING_INFO,
56079            p_next: ::std::ptr::null(),
56080            flags: RenderingFlags::default(),
56081            render_area: Rect2D::default(),
56082            layer_count: u32::default(),
56083            view_mask: u32::default(),
56084            color_attachment_count: u32::default(),
56085            p_color_attachments: ::std::ptr::null(),
56086            p_depth_attachment: ::std::ptr::null(),
56087            p_stencil_attachment: ::std::ptr::null(),
56088        }
56089    }
56090}
56091impl RenderingInfo {
56092    pub fn builder<'a>() -> RenderingInfoBuilder<'a> {
56093        RenderingInfoBuilder {
56094            inner: Self::default(),
56095            marker: ::std::marker::PhantomData,
56096        }
56097    }
56098}
56099#[repr(transparent)]
56100pub struct RenderingInfoBuilder<'a> {
56101    inner: RenderingInfo,
56102    marker: ::std::marker::PhantomData<&'a ()>,
56103}
56104pub unsafe trait ExtendsRenderingInfo {}
56105impl<'a> ::std::ops::Deref for RenderingInfoBuilder<'a> {
56106    type Target = RenderingInfo;
56107    fn deref(&self) -> &Self::Target {
56108        &self.inner
56109    }
56110}
56111impl<'a> ::std::ops::DerefMut for RenderingInfoBuilder<'a> {
56112    fn deref_mut(&mut self) -> &mut Self::Target {
56113        &mut self.inner
56114    }
56115}
56116impl<'a> RenderingInfoBuilder<'a> {
56117    pub fn flags(mut self, flags: RenderingFlags) -> Self {
56118        self.inner.flags = flags;
56119        self
56120    }
56121    pub fn render_area(mut self, render_area: Rect2D) -> Self {
56122        self.inner.render_area = render_area;
56123        self
56124    }
56125    pub fn layer_count(mut self, layer_count: u32) -> Self {
56126        self.inner.layer_count = layer_count;
56127        self
56128    }
56129    pub fn view_mask(mut self, view_mask: u32) -> Self {
56130        self.inner.view_mask = view_mask;
56131        self
56132    }
56133    pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self {
56134        self.inner.color_attachment_count = color_attachments.len() as _;
56135        self.inner.p_color_attachments = color_attachments.as_ptr();
56136        self
56137    }
56138    pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self {
56139        self.inner.p_depth_attachment = depth_attachment;
56140        self
56141    }
56142    pub fn stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self {
56143        self.inner.p_stencil_attachment = stencil_attachment;
56144        self
56145    }
56146    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
56147    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
56148    #[doc = r" valid extension structs can be pushed into the chain."]
56149    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
56150    #[doc = r" chain will look like `A -> D -> B -> C`."]
56151    pub fn push_next<T: ExtendsRenderingInfo>(mut self, next: &'a mut T) -> Self {
56152        unsafe {
56153            let next_ptr = <*const T>::cast(next);
56154            let last_next = ptr_chain_iter(next).last().unwrap();
56155            (*last_next).p_next = self.inner.p_next as _;
56156            self.inner.p_next = next_ptr;
56157        }
56158        self
56159    }
56160    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56161    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56162    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56163    pub fn build(self) -> RenderingInfo {
56164        self.inner
56165    }
56166}
56167#[repr(C)]
56168#[derive(Copy, Clone)]
56169#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingAttachmentInfo.html>"]
56170pub struct RenderingAttachmentInfo {
56171    pub s_type: StructureType,
56172    pub p_next: *const c_void,
56173    pub image_view: ImageView,
56174    pub image_layout: ImageLayout,
56175    pub resolve_mode: ResolveModeFlags,
56176    pub resolve_image_view: ImageView,
56177    pub resolve_image_layout: ImageLayout,
56178    pub load_op: AttachmentLoadOp,
56179    pub store_op: AttachmentStoreOp,
56180    pub clear_value: ClearValue,
56181}
56182#[cfg(feature = "debug")]
56183impl fmt::Debug for RenderingAttachmentInfo {
56184    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
56185        fmt.debug_struct("RenderingAttachmentInfo")
56186            .field("s_type", &self.s_type)
56187            .field("p_next", &self.p_next)
56188            .field("image_view", &self.image_view)
56189            .field("image_layout", &self.image_layout)
56190            .field("resolve_mode", &self.resolve_mode)
56191            .field("resolve_image_view", &self.resolve_image_view)
56192            .field("resolve_image_layout", &self.resolve_image_layout)
56193            .field("load_op", &self.load_op)
56194            .field("store_op", &self.store_op)
56195            .field("clear_value", &"union")
56196            .finish()
56197    }
56198}
56199impl ::std::default::Default for RenderingAttachmentInfo {
56200    fn default() -> Self {
56201        Self {
56202            s_type: StructureType::RENDERING_ATTACHMENT_INFO,
56203            p_next: ::std::ptr::null(),
56204            image_view: ImageView::default(),
56205            image_layout: ImageLayout::default(),
56206            resolve_mode: ResolveModeFlags::default(),
56207            resolve_image_view: ImageView::default(),
56208            resolve_image_layout: ImageLayout::default(),
56209            load_op: AttachmentLoadOp::default(),
56210            store_op: AttachmentStoreOp::default(),
56211            clear_value: ClearValue::default(),
56212        }
56213    }
56214}
56215impl RenderingAttachmentInfo {
56216    pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> {
56217        RenderingAttachmentInfoBuilder {
56218            inner: Self::default(),
56219            marker: ::std::marker::PhantomData,
56220        }
56221    }
56222}
56223#[repr(transparent)]
56224pub struct RenderingAttachmentInfoBuilder<'a> {
56225    inner: RenderingAttachmentInfo,
56226    marker: ::std::marker::PhantomData<&'a ()>,
56227}
56228impl<'a> ::std::ops::Deref for RenderingAttachmentInfoBuilder<'a> {
56229    type Target = RenderingAttachmentInfo;
56230    fn deref(&self) -> &Self::Target {
56231        &self.inner
56232    }
56233}
56234impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> {
56235    fn deref_mut(&mut self) -> &mut Self::Target {
56236        &mut self.inner
56237    }
56238}
56239impl<'a> RenderingAttachmentInfoBuilder<'a> {
56240    pub fn image_view(mut self, image_view: ImageView) -> Self {
56241        self.inner.image_view = image_view;
56242        self
56243    }
56244    pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
56245        self.inner.image_layout = image_layout;
56246        self
56247    }
56248    pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self {
56249        self.inner.resolve_mode = resolve_mode;
56250        self
56251    }
56252    pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self {
56253        self.inner.resolve_image_view = resolve_image_view;
56254        self
56255    }
56256    pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self {
56257        self.inner.resolve_image_layout = resolve_image_layout;
56258        self
56259    }
56260    pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
56261        self.inner.load_op = load_op;
56262        self
56263    }
56264    pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
56265        self.inner.store_op = store_op;
56266        self
56267    }
56268    pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
56269        self.inner.clear_value = clear_value;
56270        self
56271    }
56272    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56273    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56274    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56275    pub fn build(self) -> RenderingAttachmentInfo {
56276        self.inner
56277    }
56278}
56279#[repr(C)]
56280#[cfg_attr(feature = "debug", derive(Debug))]
56281#[derive(Copy, Clone)]
56282#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html>"]
56283pub struct RenderingFragmentShadingRateAttachmentInfoKHR {
56284    pub s_type: StructureType,
56285    pub p_next: *const c_void,
56286    pub image_view: ImageView,
56287    pub image_layout: ImageLayout,
56288    pub shading_rate_attachment_texel_size: Extent2D,
56289}
56290impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR {
56291    fn default() -> Self {
56292        Self {
56293            s_type: StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
56294            p_next: ::std::ptr::null(),
56295            image_view: ImageView::default(),
56296            image_layout: ImageLayout::default(),
56297            shading_rate_attachment_texel_size: Extent2D::default(),
56298        }
56299    }
56300}
56301impl RenderingFragmentShadingRateAttachmentInfoKHR {
56302    pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56303        RenderingFragmentShadingRateAttachmentInfoKHRBuilder {
56304            inner: Self::default(),
56305            marker: ::std::marker::PhantomData,
56306        }
56307    }
56308}
56309#[repr(transparent)]
56310pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56311    inner: RenderingFragmentShadingRateAttachmentInfoKHR,
56312    marker: ::std::marker::PhantomData<&'a ()>,
56313}
56314unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
56315unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR {}
56316impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56317    type Target = RenderingFragmentShadingRateAttachmentInfoKHR;
56318    fn deref(&self) -> &Self::Target {
56319        &self.inner
56320    }
56321}
56322impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56323    fn deref_mut(&mut self) -> &mut Self::Target {
56324        &mut self.inner
56325    }
56326}
56327impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
56328    pub fn image_view(mut self, image_view: ImageView) -> Self {
56329        self.inner.image_view = image_view;
56330        self
56331    }
56332    pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
56333        self.inner.image_layout = image_layout;
56334        self
56335    }
56336    pub fn shading_rate_attachment_texel_size(
56337        mut self,
56338        shading_rate_attachment_texel_size: Extent2D,
56339    ) -> Self {
56340        self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
56341        self
56342    }
56343    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56344    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56345    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56346    pub fn build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR {
56347        self.inner
56348    }
56349}
56350#[repr(C)]
56351#[cfg_attr(feature = "debug", derive(Debug))]
56352#[derive(Copy, Clone)]
56353#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html>"]
56354pub struct RenderingFragmentDensityMapAttachmentInfoEXT {
56355    pub s_type: StructureType,
56356    pub p_next: *const c_void,
56357    pub image_view: ImageView,
56358    pub image_layout: ImageLayout,
56359}
56360impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT {
56361    fn default() -> Self {
56362        Self {
56363            s_type: StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT,
56364            p_next: ::std::ptr::null(),
56365            image_view: ImageView::default(),
56366            image_layout: ImageLayout::default(),
56367        }
56368    }
56369}
56370impl RenderingFragmentDensityMapAttachmentInfoEXT {
56371    pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56372        RenderingFragmentDensityMapAttachmentInfoEXTBuilder {
56373            inner: Self::default(),
56374            marker: ::std::marker::PhantomData,
56375        }
56376    }
56377}
56378#[repr(transparent)]
56379pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56380    inner: RenderingFragmentDensityMapAttachmentInfoEXT,
56381    marker: ::std::marker::PhantomData<&'a ()>,
56382}
56383unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {}
56384unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT {}
56385impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56386    type Target = RenderingFragmentDensityMapAttachmentInfoEXT;
56387    fn deref(&self) -> &Self::Target {
56388        &self.inner
56389    }
56390}
56391impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56392    fn deref_mut(&mut self) -> &mut Self::Target {
56393        &mut self.inner
56394    }
56395}
56396impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
56397    pub fn image_view(mut self, image_view: ImageView) -> Self {
56398        self.inner.image_view = image_view;
56399        self
56400    }
56401    pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
56402        self.inner.image_layout = image_layout;
56403        self
56404    }
56405    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56406    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56407    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56408    pub fn build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT {
56409        self.inner
56410    }
56411}
56412#[repr(C)]
56413#[cfg_attr(feature = "debug", derive(Debug))]
56414#[derive(Copy, Clone)]
56415#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingFeatures.html>"]
56416pub struct PhysicalDeviceDynamicRenderingFeatures {
56417    pub s_type: StructureType,
56418    pub p_next: *mut c_void,
56419    pub dynamic_rendering: Bool32,
56420}
56421impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures {
56422    fn default() -> Self {
56423        Self {
56424            s_type: StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES,
56425            p_next: ::std::ptr::null_mut(),
56426            dynamic_rendering: Bool32::default(),
56427        }
56428    }
56429}
56430impl PhysicalDeviceDynamicRenderingFeatures {
56431    pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56432        PhysicalDeviceDynamicRenderingFeaturesBuilder {
56433            inner: Self::default(),
56434            marker: ::std::marker::PhantomData,
56435        }
56436    }
56437}
56438#[repr(transparent)]
56439pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56440    inner: PhysicalDeviceDynamicRenderingFeatures,
56441    marker: ::std::marker::PhantomData<&'a ()>,
56442}
56443unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
56444unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures {}
56445unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
56446unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures {}
56447impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56448    type Target = PhysicalDeviceDynamicRenderingFeatures;
56449    fn deref(&self) -> &Self::Target {
56450        &self.inner
56451    }
56452}
56453impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56454    fn deref_mut(&mut self) -> &mut Self::Target {
56455        &mut self.inner
56456    }
56457}
56458impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
56459    pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
56460        self.inner.dynamic_rendering = dynamic_rendering.into();
56461        self
56462    }
56463    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56464    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56465    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56466    pub fn build(self) -> PhysicalDeviceDynamicRenderingFeatures {
56467        self.inner
56468    }
56469}
56470#[repr(C)]
56471#[cfg_attr(feature = "debug", derive(Debug))]
56472#[derive(Copy, Clone)]
56473#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderingInfo.html>"]
56474pub struct CommandBufferInheritanceRenderingInfo {
56475    pub s_type: StructureType,
56476    pub p_next: *const c_void,
56477    pub flags: RenderingFlags,
56478    pub view_mask: u32,
56479    pub color_attachment_count: u32,
56480    pub p_color_attachment_formats: *const Format,
56481    pub depth_attachment_format: Format,
56482    pub stencil_attachment_format: Format,
56483    pub rasterization_samples: SampleCountFlags,
56484}
56485impl ::std::default::Default for CommandBufferInheritanceRenderingInfo {
56486    fn default() -> Self {
56487        Self {
56488            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO,
56489            p_next: ::std::ptr::null(),
56490            flags: RenderingFlags::default(),
56491            view_mask: u32::default(),
56492            color_attachment_count: u32::default(),
56493            p_color_attachment_formats: ::std::ptr::null(),
56494            depth_attachment_format: Format::default(),
56495            stencil_attachment_format: Format::default(),
56496            rasterization_samples: SampleCountFlags::default(),
56497        }
56498    }
56499}
56500impl CommandBufferInheritanceRenderingInfo {
56501    pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> {
56502        CommandBufferInheritanceRenderingInfoBuilder {
56503            inner: Self::default(),
56504            marker: ::std::marker::PhantomData,
56505        }
56506    }
56507}
56508#[repr(transparent)]
56509pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> {
56510    inner: CommandBufferInheritanceRenderingInfo,
56511    marker: ::std::marker::PhantomData<&'a ()>,
56512}
56513unsafe impl ExtendsCommandBufferInheritanceInfo
56514    for CommandBufferInheritanceRenderingInfoBuilder<'_>
56515{
56516}
56517unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo {}
56518impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> {
56519    type Target = CommandBufferInheritanceRenderingInfo;
56520    fn deref(&self) -> &Self::Target {
56521        &self.inner
56522    }
56523}
56524impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> {
56525    fn deref_mut(&mut self) -> &mut Self::Target {
56526        &mut self.inner
56527    }
56528}
56529impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> {
56530    pub fn flags(mut self, flags: RenderingFlags) -> Self {
56531        self.inner.flags = flags;
56532        self
56533    }
56534    pub fn view_mask(mut self, view_mask: u32) -> Self {
56535        self.inner.view_mask = view_mask;
56536        self
56537    }
56538    pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
56539        self.inner.color_attachment_count = color_attachment_formats.len() as _;
56540        self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
56541        self
56542    }
56543    pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
56544        self.inner.depth_attachment_format = depth_attachment_format;
56545        self
56546    }
56547    pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
56548        self.inner.stencil_attachment_format = stencil_attachment_format;
56549        self
56550    }
56551    pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
56552        self.inner.rasterization_samples = rasterization_samples;
56553        self
56554    }
56555    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56556    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56557    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56558    pub fn build(self) -> CommandBufferInheritanceRenderingInfo {
56559        self.inner
56560    }
56561}
56562#[repr(C)]
56563#[cfg_attr(feature = "debug", derive(Debug))]
56564#[derive(Copy, Clone)]
56565#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleCountInfoAMD.html>"]
56566pub struct AttachmentSampleCountInfoAMD {
56567    pub s_type: StructureType,
56568    pub p_next: *const c_void,
56569    pub color_attachment_count: u32,
56570    pub p_color_attachment_samples: *const SampleCountFlags,
56571    pub depth_stencil_attachment_samples: SampleCountFlags,
56572}
56573impl ::std::default::Default for AttachmentSampleCountInfoAMD {
56574    fn default() -> Self {
56575        Self {
56576            s_type: StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
56577            p_next: ::std::ptr::null(),
56578            color_attachment_count: u32::default(),
56579            p_color_attachment_samples: ::std::ptr::null(),
56580            depth_stencil_attachment_samples: SampleCountFlags::default(),
56581        }
56582    }
56583}
56584impl AttachmentSampleCountInfoAMD {
56585    pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> {
56586        AttachmentSampleCountInfoAMDBuilder {
56587            inner: Self::default(),
56588            marker: ::std::marker::PhantomData,
56589        }
56590    }
56591}
56592#[repr(transparent)]
56593pub struct AttachmentSampleCountInfoAMDBuilder<'a> {
56594    inner: AttachmentSampleCountInfoAMD,
56595    marker: ::std::marker::PhantomData<&'a ()>,
56596}
56597unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
56598unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {}
56599unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
56600unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {}
56601impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> {
56602    type Target = AttachmentSampleCountInfoAMD;
56603    fn deref(&self) -> &Self::Target {
56604        &self.inner
56605    }
56606}
56607impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> {
56608    fn deref_mut(&mut self) -> &mut Self::Target {
56609        &mut self.inner
56610    }
56611}
56612impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> {
56613    pub fn color_attachment_samples(
56614        mut self,
56615        color_attachment_samples: &'a [SampleCountFlags],
56616    ) -> Self {
56617        self.inner.color_attachment_count = color_attachment_samples.len() as _;
56618        self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr();
56619        self
56620    }
56621    pub fn depth_stencil_attachment_samples(
56622        mut self,
56623        depth_stencil_attachment_samples: SampleCountFlags,
56624    ) -> Self {
56625        self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_samples;
56626        self
56627    }
56628    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56629    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56630    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56631    pub fn build(self) -> AttachmentSampleCountInfoAMD {
56632        self.inner
56633    }
56634}
56635#[repr(C)]
56636#[cfg_attr(feature = "debug", derive(Debug))]
56637#[derive(Copy, Clone)]
56638#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewAttributesInfoNVX.html>"]
56639pub struct MultiviewPerViewAttributesInfoNVX {
56640    pub s_type: StructureType,
56641    pub p_next: *const c_void,
56642    pub per_view_attributes: Bool32,
56643    pub per_view_attributes_position_x_only: Bool32,
56644}
56645impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX {
56646    fn default() -> Self {
56647        Self {
56648            s_type: StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX,
56649            p_next: ::std::ptr::null(),
56650            per_view_attributes: Bool32::default(),
56651            per_view_attributes_position_x_only: Bool32::default(),
56652        }
56653    }
56654}
56655impl MultiviewPerViewAttributesInfoNVX {
56656    pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56657        MultiviewPerViewAttributesInfoNVXBuilder {
56658            inner: Self::default(),
56659            marker: ::std::marker::PhantomData,
56660        }
56661    }
56662}
56663#[repr(transparent)]
56664pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56665    inner: MultiviewPerViewAttributesInfoNVX,
56666    marker: ::std::marker::PhantomData<&'a ()>,
56667}
56668unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
56669unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {}
56670unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
56671unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {}
56672unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
56673unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX {}
56674impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56675    type Target = MultiviewPerViewAttributesInfoNVX;
56676    fn deref(&self) -> &Self::Target {
56677        &self.inner
56678    }
56679}
56680impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56681    fn deref_mut(&mut self) -> &mut Self::Target {
56682        &mut self.inner
56683    }
56684}
56685impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
56686    pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self {
56687        self.inner.per_view_attributes = per_view_attributes.into();
56688        self
56689    }
56690    pub fn per_view_attributes_position_x_only(
56691        mut self,
56692        per_view_attributes_position_x_only: bool,
56693    ) -> Self {
56694        self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into();
56695        self
56696    }
56697    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56698    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56699    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56700    pub fn build(self) -> MultiviewPerViewAttributesInfoNVX {
56701        self.inner
56702    }
56703}
56704#[repr(C)]
56705#[cfg_attr(feature = "debug", derive(Debug))]
56706#[derive(Copy, Clone)]
56707#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html>"]
56708pub struct PhysicalDeviceImageViewMinLodFeaturesEXT {
56709    pub s_type: StructureType,
56710    pub p_next: *mut c_void,
56711    pub min_lod: Bool32,
56712}
56713impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT {
56714    fn default() -> Self {
56715        Self {
56716            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT,
56717            p_next: ::std::ptr::null_mut(),
56718            min_lod: Bool32::default(),
56719        }
56720    }
56721}
56722impl PhysicalDeviceImageViewMinLodFeaturesEXT {
56723    pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56724        PhysicalDeviceImageViewMinLodFeaturesEXTBuilder {
56725            inner: Self::default(),
56726            marker: ::std::marker::PhantomData,
56727        }
56728    }
56729}
56730#[repr(transparent)]
56731pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56732    inner: PhysicalDeviceImageViewMinLodFeaturesEXT,
56733    marker: ::std::marker::PhantomData<&'a ()>,
56734}
56735unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
56736unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {}
56737unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
56738unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {}
56739impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56740    type Target = PhysicalDeviceImageViewMinLodFeaturesEXT;
56741    fn deref(&self) -> &Self::Target {
56742        &self.inner
56743    }
56744}
56745impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56746    fn deref_mut(&mut self) -> &mut Self::Target {
56747        &mut self.inner
56748    }
56749}
56750impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
56751    pub fn min_lod(mut self, min_lod: bool) -> Self {
56752        self.inner.min_lod = min_lod.into();
56753        self
56754    }
56755    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56756    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56757    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56758    pub fn build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT {
56759        self.inner
56760    }
56761}
56762#[repr(C)]
56763#[cfg_attr(feature = "debug", derive(Debug))]
56764#[derive(Copy, Clone)]
56765#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewMinLodCreateInfoEXT.html>"]
56766pub struct ImageViewMinLodCreateInfoEXT {
56767    pub s_type: StructureType,
56768    pub p_next: *const c_void,
56769    pub min_lod: f32,
56770}
56771impl ::std::default::Default for ImageViewMinLodCreateInfoEXT {
56772    fn default() -> Self {
56773        Self {
56774            s_type: StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT,
56775            p_next: ::std::ptr::null(),
56776            min_lod: f32::default(),
56777        }
56778    }
56779}
56780impl ImageViewMinLodCreateInfoEXT {
56781    pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> {
56782        ImageViewMinLodCreateInfoEXTBuilder {
56783            inner: Self::default(),
56784            marker: ::std::marker::PhantomData,
56785        }
56786    }
56787}
56788#[repr(transparent)]
56789pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> {
56790    inner: ImageViewMinLodCreateInfoEXT,
56791    marker: ::std::marker::PhantomData<&'a ()>,
56792}
56793unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {}
56794unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {}
56795impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> {
56796    type Target = ImageViewMinLodCreateInfoEXT;
56797    fn deref(&self) -> &Self::Target {
56798        &self.inner
56799    }
56800}
56801impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> {
56802    fn deref_mut(&mut self) -> &mut Self::Target {
56803        &mut self.inner
56804    }
56805}
56806impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> {
56807    pub fn min_lod(mut self, min_lod: f32) -> Self {
56808        self.inner.min_lod = min_lod;
56809        self
56810    }
56811    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56812    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56813    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56814    pub fn build(self) -> ImageViewMinLodCreateInfoEXT {
56815        self.inner
56816    }
56817}
56818#[repr(C)]
56819#[cfg_attr(feature = "debug", derive(Debug))]
56820#[derive(Copy, Clone)]
56821#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.html>"]
56822pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56823    pub s_type: StructureType,
56824    pub p_next: *mut c_void,
56825    pub rasterization_order_color_attachment_access: Bool32,
56826    pub rasterization_order_depth_attachment_access: Bool32,
56827    pub rasterization_order_stencil_attachment_access: Bool32,
56828}
56829impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56830    fn default() -> Self {
56831        Self {
56832            s_type:
56833                StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM,
56834            p_next: ::std::ptr::null_mut(),
56835            rasterization_order_color_attachment_access: Bool32::default(),
56836            rasterization_order_depth_attachment_access: Bool32::default(),
56837            rasterization_order_stencil_attachment_access: Bool32::default(),
56838        }
56839    }
56840}
56841impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56842    pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> {
56843        PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder {
56844            inner: Self::default(),
56845            marker: ::std::marker::PhantomData,
56846        }
56847    }
56848}
56849#[repr(transparent)]
56850pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> {
56851    inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM,
56852    marker: ::std::marker::PhantomData<&'a ()>,
56853}
56854unsafe impl ExtendsPhysicalDeviceFeatures2
56855    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_>
56856{
56857}
56858unsafe impl ExtendsPhysicalDeviceFeatures2
56859    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
56860{
56861}
56862unsafe impl ExtendsDeviceCreateInfo
56863    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_>
56864{
56865}
56866unsafe impl ExtendsDeviceCreateInfo
56867    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
56868{
56869}
56870impl<'a> ::std::ops::Deref
56871    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a>
56872{
56873    type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
56874    fn deref(&self) -> &Self::Target {
56875        &self.inner
56876    }
56877}
56878impl<'a> ::std::ops::DerefMut
56879    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a>
56880{
56881    fn deref_mut(&mut self) -> &mut Self::Target {
56882        &mut self.inner
56883    }
56884}
56885impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> {
56886    pub fn rasterization_order_color_attachment_access(
56887        mut self,
56888        rasterization_order_color_attachment_access: bool,
56889    ) -> Self {
56890        self.inner.rasterization_order_color_attachment_access =
56891            rasterization_order_color_attachment_access.into();
56892        self
56893    }
56894    pub fn rasterization_order_depth_attachment_access(
56895        mut self,
56896        rasterization_order_depth_attachment_access: bool,
56897    ) -> Self {
56898        self.inner.rasterization_order_depth_attachment_access =
56899            rasterization_order_depth_attachment_access.into();
56900        self
56901    }
56902    pub fn rasterization_order_stencil_attachment_access(
56903        mut self,
56904        rasterization_order_stencil_attachment_access: bool,
56905    ) -> Self {
56906        self.inner.rasterization_order_stencil_attachment_access =
56907            rasterization_order_stencil_attachment_access.into();
56908        self
56909    }
56910    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56911    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56912    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56913    pub fn build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
56914        self.inner
56915    }
56916}
56917#[repr(C)]
56918#[cfg_attr(feature = "debug", derive(Debug))]
56919#[derive(Copy, Clone)]
56920#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html>"]
56921pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV {
56922    pub s_type: StructureType,
56923    pub p_next: *mut c_void,
56924    pub linear_color_attachment: Bool32,
56925}
56926impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV {
56927    fn default() -> Self {
56928        Self {
56929            s_type: StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV,
56930            p_next: ::std::ptr::null_mut(),
56931            linear_color_attachment: Bool32::default(),
56932        }
56933    }
56934}
56935impl PhysicalDeviceLinearColorAttachmentFeaturesNV {
56936    pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56937        PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder {
56938            inner: Self::default(),
56939            marker: ::std::marker::PhantomData,
56940        }
56941    }
56942}
56943#[repr(transparent)]
56944pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56945    inner: PhysicalDeviceLinearColorAttachmentFeaturesNV,
56946    marker: ::std::marker::PhantomData<&'a ()>,
56947}
56948unsafe impl ExtendsPhysicalDeviceFeatures2
56949    for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_>
56950{
56951}
56952unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
56953unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {}
56954unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
56955impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56956    type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV;
56957    fn deref(&self) -> &Self::Target {
56958        &self.inner
56959    }
56960}
56961impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56962    fn deref_mut(&mut self) -> &mut Self::Target {
56963        &mut self.inner
56964    }
56965}
56966impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
56967    pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self {
56968        self.inner.linear_color_attachment = linear_color_attachment.into();
56969        self
56970    }
56971    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
56972    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
56973    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
56974    pub fn build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV {
56975        self.inner
56976    }
56977}
56978#[repr(C)]
56979#[cfg_attr(feature = "debug", derive(Debug))]
56980#[derive(Copy, Clone)]
56981#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html>"]
56982pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
56983    pub s_type: StructureType,
56984    pub p_next: *mut c_void,
56985    pub descriptor_set_host_mapping: Bool32,
56986}
56987impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
56988    fn default() -> Self {
56989        Self {
56990            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE,
56991            p_next: ::std::ptr::null_mut(),
56992            descriptor_set_host_mapping: Bool32::default(),
56993        }
56994    }
56995}
56996impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
56997    pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
56998        PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder {
56999            inner: Self::default(),
57000            marker: ::std::marker::PhantomData,
57001        }
57002    }
57003}
57004#[repr(transparent)]
57005pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57006    inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE,
57007    marker: ::std::marker::PhantomData<&'a ()>,
57008}
57009unsafe impl ExtendsPhysicalDeviceFeatures2
57010    for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
57011{
57012}
57013unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
57014unsafe impl ExtendsDeviceCreateInfo
57015    for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
57016{
57017}
57018unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
57019impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57020    type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
57021    fn deref(&self) -> &Self::Target {
57022        &self.inner
57023    }
57024}
57025impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57026    fn deref_mut(&mut self) -> &mut Self::Target {
57027        &mut self.inner
57028    }
57029}
57030impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
57031    pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self {
57032        self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into();
57033        self
57034    }
57035    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57036    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57037    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
57038    pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
57039        self.inner
57040    }
57041}
57042#[repr(C)]
57043#[cfg_attr(feature = "debug", derive(Debug))]
57044#[derive(Copy, Clone)]
57045#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetBindingReferenceVALVE.html>"]
57046pub struct DescriptorSetBindingReferenceVALVE {
57047    pub s_type: StructureType,
57048    pub p_next: *const c_void,
57049    pub descriptor_set_layout: DescriptorSetLayout,
57050    pub binding: u32,
57051}
57052impl ::std::default::Default for DescriptorSetBindingReferenceVALVE {
57053    fn default() -> Self {
57054        Self {
57055            s_type: StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE,
57056            p_next: ::std::ptr::null(),
57057            descriptor_set_layout: DescriptorSetLayout::default(),
57058            binding: u32::default(),
57059        }
57060    }
57061}
57062impl DescriptorSetBindingReferenceVALVE {
57063    pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> {
57064        DescriptorSetBindingReferenceVALVEBuilder {
57065            inner: Self::default(),
57066            marker: ::std::marker::PhantomData,
57067        }
57068    }
57069}
57070#[repr(transparent)]
57071pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> {
57072    inner: DescriptorSetBindingReferenceVALVE,
57073    marker: ::std::marker::PhantomData<&'a ()>,
57074}
57075impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> {
57076    type Target = DescriptorSetBindingReferenceVALVE;
57077    fn deref(&self) -> &Self::Target {
57078        &self.inner
57079    }
57080}
57081impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> {
57082    fn deref_mut(&mut self) -> &mut Self::Target {
57083        &mut self.inner
57084    }
57085}
57086impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> {
57087    pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
57088        self.inner.descriptor_set_layout = descriptor_set_layout;
57089        self
57090    }
57091    pub fn binding(mut self, binding: u32) -> Self {
57092        self.inner.binding = binding;
57093        self
57094    }
57095    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57096    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57097    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
57098    pub fn build(self) -> DescriptorSetBindingReferenceVALVE {
57099        self.inner
57100    }
57101}
57102#[repr(C)]
57103#[cfg_attr(feature = "debug", derive(Debug))]
57104#[derive(Copy, Clone)]
57105#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html>"]
57106pub struct DescriptorSetLayoutHostMappingInfoVALVE {
57107    pub s_type: StructureType,
57108    pub p_next: *mut c_void,
57109    pub descriptor_offset: usize,
57110    pub descriptor_size: u32,
57111}
57112impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE {
57113    fn default() -> Self {
57114        Self {
57115            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE,
57116            p_next: ::std::ptr::null_mut(),
57117            descriptor_offset: usize::default(),
57118            descriptor_size: u32::default(),
57119        }
57120    }
57121}
57122impl DescriptorSetLayoutHostMappingInfoVALVE {
57123    pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57124        DescriptorSetLayoutHostMappingInfoVALVEBuilder {
57125            inner: Self::default(),
57126            marker: ::std::marker::PhantomData,
57127        }
57128    }
57129}
57130#[repr(transparent)]
57131pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57132    inner: DescriptorSetLayoutHostMappingInfoVALVE,
57133    marker: ::std::marker::PhantomData<&'a ()>,
57134}
57135impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57136    type Target = DescriptorSetLayoutHostMappingInfoVALVE;
57137    fn deref(&self) -> &Self::Target {
57138        &self.inner
57139    }
57140}
57141impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57142    fn deref_mut(&mut self) -> &mut Self::Target {
57143        &mut self.inner
57144    }
57145}
57146impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
57147    pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self {
57148        self.inner.descriptor_offset = descriptor_offset;
57149        self
57150    }
57151    pub fn descriptor_size(mut self, descriptor_size: u32) -> Self {
57152        self.inner.descriptor_size = descriptor_size;
57153        self
57154    }
57155    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
57156    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
57157    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
57158    pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE {
57159        self.inner
57160    }
57161}