1 use crate::vk::aliases::*;
2 use crate::vk::bitflags::*;
3 use crate::vk::constants::*;
4 use crate::vk::enums::*;
5 use crate::vk::platform_types::*;
6 use crate::vk::{ptr_chain_iter, Handle};
7 use std::fmt;
8 use std::os::raw::*;
9 pub const API_VERSION_1_0: u32 = crate::vk::make_version(1, 0, 0);
10 pub const API_VERSION_1_1: u32 = crate::vk::make_version(1, 1, 0);
11 pub const API_VERSION_1_2: u32 = crate::vk::make_version(1, 2, 0);
12 pub const HEADER_VERSION: u32 = 168u32;
13 pub const HEADER_VERSION_COMPLETE: u32 = crate::vk::make_version(1, 2, HEADER_VERSION);
14 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleMask.html>"]
15 pub type SampleMask = u32;
16 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBool32.html>"]
17 pub type Bool32 = u32;
18 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFlags.html>"]
19 pub type Flags = u32;
20 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceSize.html>"]
21 pub type DeviceSize = u64;
22 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceAddress.html>"]
23 pub type DeviceAddress = u64;
24 #[repr(transparent)]
25 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
26 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateFlags.html>"]
27 pub struct QueryPoolCreateFlags(pub(crate) Flags);
28 vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags);
29 #[repr(transparent)]
30 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
31 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateFlags.html>"]
32 pub struct PipelineLayoutCreateFlags(pub(crate) Flags);
33 vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags);
34 #[repr(transparent)]
35 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
36 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateFlags.html>"]
37 pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags);
38 vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags);
39 #[repr(transparent)]
40 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
41 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
42 pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags);
43 vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags);
44 #[repr(transparent)]
45 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
46 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateFlags.html>"]
47 pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags);
48 vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags);
49 #[repr(transparent)]
50 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
51 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
52 pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags);
53 vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags);
54 #[repr(transparent)]
55 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
56 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
57 pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags);
58 vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags);
59 #[repr(transparent)]
60 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
61 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
62 pub struct PipelineViewportStateCreateFlags(pub(crate) Flags);
63 vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags);
64 #[repr(transparent)]
65 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
66 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
67 pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags);
68 vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags);
69 #[repr(transparent)]
70 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
71 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
72 pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags);
73 vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags);
74 #[repr(transparent)]
75 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
76 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
77 pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags);
78 vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags);
79 #[repr(transparent)]
80 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
81 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateFlags.html>"]
82 pub struct BufferViewCreateFlags(pub(crate) Flags);
83 vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags);
84 #[repr(transparent)]
85 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
86 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateFlags.html>"]
87 pub struct InstanceCreateFlags(pub(crate) Flags);
88 vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags);
89 #[repr(transparent)]
90 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
91 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateFlags.html>"]
92 pub struct DeviceCreateFlags(pub(crate) Flags);
93 vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags);
94 #[repr(transparent)]
95 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
96 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateFlags.html>"]
97 pub struct SemaphoreCreateFlags(pub(crate) Flags);
98 vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags);
99 #[repr(transparent)]
100 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
101 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateFlags.html>"]
102 pub struct EventCreateFlags(pub(crate) Flags);
103 vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags);
104 #[repr(transparent)]
105 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
106 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryMapFlags.html>"]
107 pub struct MemoryMapFlags(pub(crate) Flags);
108 vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags);
109 #[repr(transparent)]
110 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
111 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
112 pub struct DescriptorPoolResetFlags(pub(crate) Flags);
113 vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags);
114 #[repr(transparent)]
115 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
116 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
117 pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags);
118 vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags);
119 #[repr(transparent)]
120 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
121 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
122 pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags);
123 vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags);
124 #[repr(transparent)]
125 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
126 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
127 pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags);
128 vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags);
129 #[repr(transparent)]
130 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
131 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
132 pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags);
133 vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags);
134 #[repr(transparent)]
135 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
136 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
137 pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags);
138 vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags);
139 #[repr(transparent)]
140 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
141 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
142 pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags);
143 vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags);
144 #[repr(transparent)]
145 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
146 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
147 pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags);
148 vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags);
149 #[repr(transparent)]
150 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
151 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
152 pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags);
153 vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags);
154 #[repr(transparent)]
155 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
156 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
157 pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags);
158 vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags);
159 #[repr(transparent)]
160 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
161 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"]
162 pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags);
163 vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, 0b0, Flags);
164 #[repr(transparent)]
165 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
166 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
167 pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags);
168 vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags);
169 #[repr(transparent)]
170 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
171 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
172 pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags);
173 vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags);
174 #[repr(transparent)]
175 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
176 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
177 pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags);
178 vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, 0b0, Flags);
179 #[repr(transparent)]
180 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
181 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
182 pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags);
183 vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, 0b0, Flags);
184 #[repr(transparent)]
185 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
186 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
187 pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags);
188 vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, 0b0, Flags);
189 #[repr(transparent)]
190 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
191 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
192 pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags);
193 vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, 0b0, Flags);
194 #[repr(transparent)]
195 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
196 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolTrimFlags.html>"]
197 pub struct CommandPoolTrimFlags(pub(crate) Flags);
198 vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags);
199 #[repr(transparent)]
200 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
201 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
202 pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags);
203 vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags);
204 #[repr(transparent)]
205 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
206 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
207 pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags);
208 vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags);
209 #[repr(transparent)]
210 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
211 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
212 pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags);
213 vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags);
214 #[repr(transparent)]
215 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
216 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
217 pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags);
218 vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags);
219 #[repr(transparent)]
220 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
221 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
222 pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags);
223 vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, 0b0, Flags);
224 #[repr(transparent)]
225 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
226 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
227 pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags);
228 vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags);
229 #[repr(transparent)]
230 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
231 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
232 pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags);
233 vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags);
234 #[repr(transparent)]
235 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
236 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
237 pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags);
238 vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags);
239 #[repr(transparent)]
240 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
241 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"]
242 pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags);
243 vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, 0b0, Flags);
244 #[repr(transparent)]
245 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
246 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
247 pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags);
248 vk_bitflags_wrapped!(
249     PipelineRasterizationConservativeStateCreateFlagsEXT,
250     0b0,
251     Flags
252 );
253 #[repr(transparent)]
254 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
255 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
256 pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags);
257 vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, 0b0, Flags);
258 #[repr(transparent)]
259 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
260 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
261 pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags);
262 vk_bitflags_wrapped!(
263     PipelineRasterizationDepthClipStateCreateFlagsEXT,
264     0b0,
265     Flags
266 );
267 define_handle!(
268     Instance,
269     INSTANCE,
270     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstance.html>"
271 );
272 define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice.html>") ;
273 define_handle!(
274     Device,
275     DEVICE,
276     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevice.html>"
277 );
278 define_handle!(
279     Queue,
280     QUEUE,
281     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueue.html>"
282 );
283 define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBuffer.html>") ;
284 handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemory.html>") ;
285 handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPool.html>") ;
286 handle_nondispatchable!(
287     Buffer,
288     BUFFER,
289     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuffer.html>"
290 );
291 handle_nondispatchable!(
292     BufferView,
293     BUFFER_VIEW,
294     doc =
295         "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferView.html>"
296 );
297 handle_nondispatchable!(
298     Image,
299     IMAGE,
300     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImage.html>"
301 );
302 handle_nondispatchable!(
303     ImageView,
304     IMAGE_VIEW,
305     doc =
306         "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageView.html>"
307 );
308 handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModule.html>") ;
309 handle_nondispatchable!(
310     Pipeline,
311     PIPELINE,
312     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipeline.html>"
313 );
314 handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayout.html>") ;
315 handle_nondispatchable!(
316     Sampler,
317     SAMPLER,
318     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampler.html>"
319 );
320 handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSet.html>") ;
321 handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayout.html>") ;
322 handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPool.html>") ;
323 handle_nondispatchable!(
324     Fence,
325     FENCE,
326     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFence.html>"
327 );
328 handle_nondispatchable!(
329     Semaphore,
330     SEMAPHORE,
331     doc =
332         "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphore.html>"
333 );
334 handle_nondispatchable!(
335     Event,
336     EVENT,
337     doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEvent.html>"
338 );
339 handle_nondispatchable!(
340     QueryPool,
341     QUERY_POOL,
342     doc =
343         "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPool.html>"
344 );
345 handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebuffer.html>") ;
346 handle_nondispatchable!(
347     RenderPass,
348     RENDER_PASS,
349     doc =
350         "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPass.html>"
351 );
352 handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCache.html>") ;
353 handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutNV.html>") ;
354 handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplate.html>") ;
355 handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversion.html>") ;
356 handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheEXT.html>") ;
357 handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureKHR.html>") ;
358 handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureNV.html>") ;
359 handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceConfigurationINTEL.html>") ;
360 handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeferredOperationKHR.html>") ;
361 handle_nondispatchable ! (PrivateDataSlotEXT , PRIVATE_DATA_SLOT_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotEXT.html>") ;
362 handle_nondispatchable!(
363     DisplayKHR,
364     DISPLAY_KHR,
365     doc =
366         "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayKHR.html>"
367 );
368 handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeKHR.html>") ;
369 handle_nondispatchable!(
370     SurfaceKHR,
371     SURFACE_KHR,
372     doc =
373         "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceKHR.html>"
374 );
375 handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainKHR.html>") ;
376 handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportCallbackEXT.html>") ;
377 handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerEXT.html>") ;
378 #[allow(non_camel_case_types)]
379 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkInternalAllocationNotification.html>"]
380 pub type PFN_vkInternalAllocationNotification = Option<
381     unsafe extern "system" fn(
382         p_user_data: *mut c_void,
383         size: usize,
384         allocation_type: InternalAllocationType,
385         allocation_scope: SystemAllocationScope,
386     ),
387 >;
388 #[allow(non_camel_case_types)]
389 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkInternalFreeNotification.html>"]
390 pub type PFN_vkInternalFreeNotification = Option<
391     unsafe extern "system" fn(
392         p_user_data: *mut c_void,
393         size: usize,
394         allocation_type: InternalAllocationType,
395         allocation_scope: SystemAllocationScope,
396     ),
397 >;
398 #[allow(non_camel_case_types)]
399 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkReallocationFunction.html>"]
400 pub type PFN_vkReallocationFunction = Option<
401     unsafe extern "system" fn(
402         p_user_data: *mut c_void,
403         p_original: *mut c_void,
404         size: usize,
405         alignment: usize,
406         allocation_scope: SystemAllocationScope,
407     ) -> *mut c_void,
408 >;
409 #[allow(non_camel_case_types)]
410 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkAllocationFunction.html>"]
411 pub type PFN_vkAllocationFunction = Option<
412     unsafe extern "system" fn(
413         p_user_data: *mut c_void,
414         size: usize,
415         alignment: usize,
416         allocation_scope: SystemAllocationScope,
417     ) -> *mut c_void,
418 >;
419 #[allow(non_camel_case_types)]
420 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkFreeFunction.html>"]
421 pub type PFN_vkFreeFunction =
422     Option<unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void)>;
423 #[allow(non_camel_case_types)]
424 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkVoidFunction.html>"]
425 pub type PFN_vkVoidFunction = Option<unsafe extern "system" fn()>;
426 #[allow(non_camel_case_types)]
427 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDebugReportCallbackEXT.html>"]
428 pub type PFN_vkDebugReportCallbackEXT = Option<
429     unsafe extern "system" fn(
430         flags: DebugReportFlagsEXT,
431         object_type: DebugReportObjectTypeEXT,
432         object: u64,
433         location: usize,
434         message_code: i32,
435         p_layer_prefix: *const c_char,
436         p_message: *const c_char,
437         p_user_data: *mut c_void,
438     ) -> Bool32,
439 >;
440 #[allow(non_camel_case_types)]
441 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html>"]
442 pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
443     unsafe extern "system" fn(
444         message_severity: DebugUtilsMessageSeverityFlagsEXT,
445         message_types: DebugUtilsMessageTypeFlagsEXT,
446         p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
447         p_user_data: *mut c_void,
448     ) -> Bool32,
449 >;
450 #[allow(non_camel_case_types)]
451 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDeviceMemoryReportCallbackEXT.html>"]
452 pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<
453     unsafe extern "system" fn(
454         p_callback_data: *const DeviceMemoryReportCallbackDataEXT,
455         p_user_data: *mut c_void,
456     ),
457 >;
458 #[repr(C)]
459 #[derive(Copy, Clone, Debug)]
460 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBaseOutStructure.html>"]
461 pub struct BaseOutStructure {
462     pub s_type: StructureType,
463     pub p_next: *mut BaseOutStructure,
464 }
465 impl ::std::default::Default for BaseOutStructure {
default() -> BaseOutStructure466     fn default() -> BaseOutStructure {
467         BaseOutStructure {
468             s_type: unsafe { ::std::mem::zeroed() },
469             p_next: ::std::ptr::null_mut(),
470         }
471     }
472 }
473 #[repr(C)]
474 #[derive(Copy, Clone, Debug)]
475 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBaseInStructure.html>"]
476 pub struct BaseInStructure {
477     pub s_type: StructureType,
478     pub p_next: *const BaseInStructure,
479 }
480 impl ::std::default::Default for BaseInStructure {
default() -> BaseInStructure481     fn default() -> BaseInStructure {
482         BaseInStructure {
483             s_type: unsafe { ::std::mem::zeroed() },
484             p_next: ::std::ptr::null(),
485         }
486     }
487 }
488 #[repr(C)]
489 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
490 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkOffset2D.html>"]
491 pub struct Offset2D {
492     pub x: i32,
493     pub y: i32,
494 }
495 impl Offset2D {
builder<'a>() -> Offset2DBuilder<'a>496     pub fn builder<'a>() -> Offset2DBuilder<'a> {
497         Offset2DBuilder {
498             inner: Offset2D::default(),
499             marker: ::std::marker::PhantomData,
500         }
501     }
502 }
503 #[repr(transparent)]
504 pub struct Offset2DBuilder<'a> {
505     inner: Offset2D,
506     marker: ::std::marker::PhantomData<&'a ()>,
507 }
508 impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> {
509     type Target = Offset2D;
deref(&self) -> &Self::Target510     fn deref(&self) -> &Self::Target {
511         &self.inner
512     }
513 }
514 impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target515     fn deref_mut(&mut self) -> &mut Self::Target {
516         &mut self.inner
517     }
518 }
519 impl<'a> Offset2DBuilder<'a> {
x(mut self, x: i32) -> Offset2DBuilder<'a>520     pub fn x(mut self, x: i32) -> Offset2DBuilder<'a> {
521         self.inner.x = x;
522         self
523     }
y(mut self, y: i32) -> Offset2DBuilder<'a>524     pub fn y(mut self, y: i32) -> Offset2DBuilder<'a> {
525         self.inner.y = y;
526         self
527     }
528     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
529     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
530     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Offset2D531     pub fn build(self) -> Offset2D {
532         self.inner
533     }
534 }
535 #[repr(C)]
536 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
537 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkOffset3D.html>"]
538 pub struct Offset3D {
539     pub x: i32,
540     pub y: i32,
541     pub z: i32,
542 }
543 impl Offset3D {
builder<'a>() -> Offset3DBuilder<'a>544     pub fn builder<'a>() -> Offset3DBuilder<'a> {
545         Offset3DBuilder {
546             inner: Offset3D::default(),
547             marker: ::std::marker::PhantomData,
548         }
549     }
550 }
551 #[repr(transparent)]
552 pub struct Offset3DBuilder<'a> {
553     inner: Offset3D,
554     marker: ::std::marker::PhantomData<&'a ()>,
555 }
556 impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> {
557     type Target = Offset3D;
deref(&self) -> &Self::Target558     fn deref(&self) -> &Self::Target {
559         &self.inner
560     }
561 }
562 impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target563     fn deref_mut(&mut self) -> &mut Self::Target {
564         &mut self.inner
565     }
566 }
567 impl<'a> Offset3DBuilder<'a> {
x(mut self, x: i32) -> Offset3DBuilder<'a>568     pub fn x(mut self, x: i32) -> Offset3DBuilder<'a> {
569         self.inner.x = x;
570         self
571     }
y(mut self, y: i32) -> Offset3DBuilder<'a>572     pub fn y(mut self, y: i32) -> Offset3DBuilder<'a> {
573         self.inner.y = y;
574         self
575     }
z(mut self, z: i32) -> Offset3DBuilder<'a>576     pub fn z(mut self, z: i32) -> Offset3DBuilder<'a> {
577         self.inner.z = z;
578         self
579     }
580     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
581     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
582     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Offset3D583     pub fn build(self) -> Offset3D {
584         self.inner
585     }
586 }
587 #[repr(C)]
588 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
589 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtent2D.html>"]
590 pub struct Extent2D {
591     pub width: u32,
592     pub height: u32,
593 }
594 impl Extent2D {
builder<'a>() -> Extent2DBuilder<'a>595     pub fn builder<'a>() -> Extent2DBuilder<'a> {
596         Extent2DBuilder {
597             inner: Extent2D::default(),
598             marker: ::std::marker::PhantomData,
599         }
600     }
601 }
602 #[repr(transparent)]
603 pub struct Extent2DBuilder<'a> {
604     inner: Extent2D,
605     marker: ::std::marker::PhantomData<&'a ()>,
606 }
607 impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> {
608     type Target = Extent2D;
deref(&self) -> &Self::Target609     fn deref(&self) -> &Self::Target {
610         &self.inner
611     }
612 }
613 impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target614     fn deref_mut(&mut self) -> &mut Self::Target {
615         &mut self.inner
616     }
617 }
618 impl<'a> Extent2DBuilder<'a> {
width(mut self, width: u32) -> Extent2DBuilder<'a>619     pub fn width(mut self, width: u32) -> Extent2DBuilder<'a> {
620         self.inner.width = width;
621         self
622     }
height(mut self, height: u32) -> Extent2DBuilder<'a>623     pub fn height(mut self, height: u32) -> Extent2DBuilder<'a> {
624         self.inner.height = height;
625         self
626     }
627     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
628     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
629     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Extent2D630     pub fn build(self) -> Extent2D {
631         self.inner
632     }
633 }
634 #[repr(C)]
635 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
636 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtent3D.html>"]
637 pub struct Extent3D {
638     pub width: u32,
639     pub height: u32,
640     pub depth: u32,
641 }
642 impl Extent3D {
builder<'a>() -> Extent3DBuilder<'a>643     pub fn builder<'a>() -> Extent3DBuilder<'a> {
644         Extent3DBuilder {
645             inner: Extent3D::default(),
646             marker: ::std::marker::PhantomData,
647         }
648     }
649 }
650 #[repr(transparent)]
651 pub struct Extent3DBuilder<'a> {
652     inner: Extent3D,
653     marker: ::std::marker::PhantomData<&'a ()>,
654 }
655 impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> {
656     type Target = Extent3D;
deref(&self) -> &Self::Target657     fn deref(&self) -> &Self::Target {
658         &self.inner
659     }
660 }
661 impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target662     fn deref_mut(&mut self) -> &mut Self::Target {
663         &mut self.inner
664     }
665 }
666 impl<'a> Extent3DBuilder<'a> {
width(mut self, width: u32) -> Extent3DBuilder<'a>667     pub fn width(mut self, width: u32) -> Extent3DBuilder<'a> {
668         self.inner.width = width;
669         self
670     }
height(mut self, height: u32) -> Extent3DBuilder<'a>671     pub fn height(mut self, height: u32) -> Extent3DBuilder<'a> {
672         self.inner.height = height;
673         self
674     }
depth(mut self, depth: u32) -> Extent3DBuilder<'a>675     pub fn depth(mut self, depth: u32) -> Extent3DBuilder<'a> {
676         self.inner.depth = depth;
677         self
678     }
679     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
680     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
681     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Extent3D682     pub fn build(self) -> Extent3D {
683         self.inner
684     }
685 }
686 #[repr(C)]
687 #[derive(Copy, Clone, Default, Debug)]
688 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewport.html>"]
689 pub struct Viewport {
690     pub x: f32,
691     pub y: f32,
692     pub width: f32,
693     pub height: f32,
694     pub min_depth: f32,
695     pub max_depth: f32,
696 }
697 impl Viewport {
builder<'a>() -> ViewportBuilder<'a>698     pub fn builder<'a>() -> ViewportBuilder<'a> {
699         ViewportBuilder {
700             inner: Viewport::default(),
701             marker: ::std::marker::PhantomData,
702         }
703     }
704 }
705 #[repr(transparent)]
706 pub struct ViewportBuilder<'a> {
707     inner: Viewport,
708     marker: ::std::marker::PhantomData<&'a ()>,
709 }
710 impl<'a> ::std::ops::Deref for ViewportBuilder<'a> {
711     type Target = Viewport;
deref(&self) -> &Self::Target712     fn deref(&self) -> &Self::Target {
713         &self.inner
714     }
715 }
716 impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target717     fn deref_mut(&mut self) -> &mut Self::Target {
718         &mut self.inner
719     }
720 }
721 impl<'a> ViewportBuilder<'a> {
x(mut self, x: f32) -> ViewportBuilder<'a>722     pub fn x(mut self, x: f32) -> ViewportBuilder<'a> {
723         self.inner.x = x;
724         self
725     }
y(mut self, y: f32) -> ViewportBuilder<'a>726     pub fn y(mut self, y: f32) -> ViewportBuilder<'a> {
727         self.inner.y = y;
728         self
729     }
width(mut self, width: f32) -> ViewportBuilder<'a>730     pub fn width(mut self, width: f32) -> ViewportBuilder<'a> {
731         self.inner.width = width;
732         self
733     }
height(mut self, height: f32) -> ViewportBuilder<'a>734     pub fn height(mut self, height: f32) -> ViewportBuilder<'a> {
735         self.inner.height = height;
736         self
737     }
min_depth(mut self, min_depth: f32) -> ViewportBuilder<'a>738     pub fn min_depth(mut self, min_depth: f32) -> ViewportBuilder<'a> {
739         self.inner.min_depth = min_depth;
740         self
741     }
max_depth(mut self, max_depth: f32) -> ViewportBuilder<'a>742     pub fn max_depth(mut self, max_depth: f32) -> ViewportBuilder<'a> {
743         self.inner.max_depth = max_depth;
744         self
745     }
746     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
747     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
748     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Viewport749     pub fn build(self) -> Viewport {
750         self.inner
751     }
752 }
753 #[repr(C)]
754 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
755 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRect2D.html>"]
756 pub struct Rect2D {
757     pub offset: Offset2D,
758     pub extent: Extent2D,
759 }
760 impl Rect2D {
builder<'a>() -> Rect2DBuilder<'a>761     pub fn builder<'a>() -> Rect2DBuilder<'a> {
762         Rect2DBuilder {
763             inner: Rect2D::default(),
764             marker: ::std::marker::PhantomData,
765         }
766     }
767 }
768 #[repr(transparent)]
769 pub struct Rect2DBuilder<'a> {
770     inner: Rect2D,
771     marker: ::std::marker::PhantomData<&'a ()>,
772 }
773 impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> {
774     type Target = Rect2D;
deref(&self) -> &Self::Target775     fn deref(&self) -> &Self::Target {
776         &self.inner
777     }
778 }
779 impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target780     fn deref_mut(&mut self) -> &mut Self::Target {
781         &mut self.inner
782     }
783 }
784 impl<'a> Rect2DBuilder<'a> {
offset(mut self, offset: Offset2D) -> Rect2DBuilder<'a>785     pub fn offset(mut self, offset: Offset2D) -> Rect2DBuilder<'a> {
786         self.inner.offset = offset;
787         self
788     }
extent(mut self, extent: Extent2D) -> Rect2DBuilder<'a>789     pub fn extent(mut self, extent: Extent2D) -> Rect2DBuilder<'a> {
790         self.inner.extent = extent;
791         self
792     }
793     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
794     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
795     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Rect2D796     pub fn build(self) -> Rect2D {
797         self.inner
798     }
799 }
800 #[repr(C)]
801 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
802 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearRect.html>"]
803 pub struct ClearRect {
804     pub rect: Rect2D,
805     pub base_array_layer: u32,
806     pub layer_count: u32,
807 }
808 impl ClearRect {
builder<'a>() -> ClearRectBuilder<'a>809     pub fn builder<'a>() -> ClearRectBuilder<'a> {
810         ClearRectBuilder {
811             inner: ClearRect::default(),
812             marker: ::std::marker::PhantomData,
813         }
814     }
815 }
816 #[repr(transparent)]
817 pub struct ClearRectBuilder<'a> {
818     inner: ClearRect,
819     marker: ::std::marker::PhantomData<&'a ()>,
820 }
821 impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> {
822     type Target = ClearRect;
deref(&self) -> &Self::Target823     fn deref(&self) -> &Self::Target {
824         &self.inner
825     }
826 }
827 impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target828     fn deref_mut(&mut self) -> &mut Self::Target {
829         &mut self.inner
830     }
831 }
832 impl<'a> ClearRectBuilder<'a> {
rect(mut self, rect: Rect2D) -> ClearRectBuilder<'a>833     pub fn rect(mut self, rect: Rect2D) -> ClearRectBuilder<'a> {
834         self.inner.rect = rect;
835         self
836     }
base_array_layer(mut self, base_array_layer: u32) -> ClearRectBuilder<'a>837     pub fn base_array_layer(mut self, base_array_layer: u32) -> ClearRectBuilder<'a> {
838         self.inner.base_array_layer = base_array_layer;
839         self
840     }
layer_count(mut self, layer_count: u32) -> ClearRectBuilder<'a>841     pub fn layer_count(mut self, layer_count: u32) -> ClearRectBuilder<'a> {
842         self.inner.layer_count = layer_count;
843         self
844     }
845     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
846     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
847     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ClearRect848     pub fn build(self) -> ClearRect {
849         self.inner
850     }
851 }
852 #[repr(C)]
853 #[derive(Copy, Clone, Default, Debug)]
854 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComponentMapping.html>"]
855 pub struct ComponentMapping {
856     pub r: ComponentSwizzle,
857     pub g: ComponentSwizzle,
858     pub b: ComponentSwizzle,
859     pub a: ComponentSwizzle,
860 }
861 impl ComponentMapping {
builder<'a>() -> ComponentMappingBuilder<'a>862     pub fn builder<'a>() -> ComponentMappingBuilder<'a> {
863         ComponentMappingBuilder {
864             inner: ComponentMapping::default(),
865             marker: ::std::marker::PhantomData,
866         }
867     }
868 }
869 #[repr(transparent)]
870 pub struct ComponentMappingBuilder<'a> {
871     inner: ComponentMapping,
872     marker: ::std::marker::PhantomData<&'a ()>,
873 }
874 impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> {
875     type Target = ComponentMapping;
deref(&self) -> &Self::Target876     fn deref(&self) -> &Self::Target {
877         &self.inner
878     }
879 }
880 impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target881     fn deref_mut(&mut self) -> &mut Self::Target {
882         &mut self.inner
883     }
884 }
885 impl<'a> ComponentMappingBuilder<'a> {
r(mut self, r: ComponentSwizzle) -> ComponentMappingBuilder<'a>886     pub fn r(mut self, r: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
887         self.inner.r = r;
888         self
889     }
g(mut self, g: ComponentSwizzle) -> ComponentMappingBuilder<'a>890     pub fn g(mut self, g: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
891         self.inner.g = g;
892         self
893     }
b(mut self, b: ComponentSwizzle) -> ComponentMappingBuilder<'a>894     pub fn b(mut self, b: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
895         self.inner.b = b;
896         self
897     }
a(mut self, a: ComponentSwizzle) -> ComponentMappingBuilder<'a>898     pub fn a(mut self, a: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
899         self.inner.a = a;
900         self
901     }
902     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
903     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
904     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ComponentMapping905     pub fn build(self) -> ComponentMapping {
906         self.inner
907     }
908 }
909 #[repr(C)]
910 #[derive(Copy, Clone)]
911 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html>"]
912 pub struct PhysicalDeviceProperties {
913     pub api_version: u32,
914     pub driver_version: u32,
915     pub vendor_id: u32,
916     pub device_id: u32,
917     pub device_type: PhysicalDeviceType,
918     pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE],
919     pub pipeline_cache_uuid: [u8; UUID_SIZE],
920     pub limits: PhysicalDeviceLimits,
921     pub sparse_properties: PhysicalDeviceSparseProperties,
922 }
923 impl fmt::Debug for PhysicalDeviceProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result924     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
925         fmt.debug_struct("PhysicalDeviceProperties")
926             .field("api_version", &self.api_version)
927             .field("driver_version", &self.driver_version)
928             .field("vendor_id", &self.vendor_id)
929             .field("device_id", &self.device_id)
930             .field("device_type", &self.device_type)
931             .field("device_name", &unsafe {
932                 ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const c_char)
933             })
934             .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
935             .field("limits", &self.limits)
936             .field("sparse_properties", &self.sparse_properties)
937             .finish()
938     }
939 }
940 impl ::std::default::Default for PhysicalDeviceProperties {
default() -> PhysicalDeviceProperties941     fn default() -> PhysicalDeviceProperties {
942         PhysicalDeviceProperties {
943             api_version: u32::default(),
944             driver_version: u32::default(),
945             vendor_id: u32::default(),
946             device_id: u32::default(),
947             device_type: PhysicalDeviceType::default(),
948             device_name: unsafe { ::std::mem::zeroed() },
949             pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
950             limits: PhysicalDeviceLimits::default(),
951             sparse_properties: PhysicalDeviceSparseProperties::default(),
952         }
953     }
954 }
955 impl PhysicalDeviceProperties {
builder<'a>() -> PhysicalDevicePropertiesBuilder<'a>956     pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> {
957         PhysicalDevicePropertiesBuilder {
958             inner: PhysicalDeviceProperties::default(),
959             marker: ::std::marker::PhantomData,
960         }
961     }
962 }
963 #[repr(transparent)]
964 pub struct PhysicalDevicePropertiesBuilder<'a> {
965     inner: PhysicalDeviceProperties,
966     marker: ::std::marker::PhantomData<&'a ()>,
967 }
968 impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> {
969     type Target = PhysicalDeviceProperties;
deref(&self) -> &Self::Target970     fn deref(&self) -> &Self::Target {
971         &self.inner
972     }
973 }
974 impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target975     fn deref_mut(&mut self) -> &mut Self::Target {
976         &mut self.inner
977     }
978 }
979 impl<'a> PhysicalDevicePropertiesBuilder<'a> {
api_version(mut self, api_version: u32) -> PhysicalDevicePropertiesBuilder<'a>980     pub fn api_version(mut self, api_version: u32) -> PhysicalDevicePropertiesBuilder<'a> {
981         self.inner.api_version = api_version;
982         self
983     }
driver_version(mut self, driver_version: u32) -> PhysicalDevicePropertiesBuilder<'a>984     pub fn driver_version(mut self, driver_version: u32) -> PhysicalDevicePropertiesBuilder<'a> {
985         self.inner.driver_version = driver_version;
986         self
987     }
vendor_id(mut self, vendor_id: u32) -> PhysicalDevicePropertiesBuilder<'a>988     pub fn vendor_id(mut self, vendor_id: u32) -> PhysicalDevicePropertiesBuilder<'a> {
989         self.inner.vendor_id = vendor_id;
990         self
991     }
device_id(mut self, device_id: u32) -> PhysicalDevicePropertiesBuilder<'a>992     pub fn device_id(mut self, device_id: u32) -> PhysicalDevicePropertiesBuilder<'a> {
993         self.inner.device_id = device_id;
994         self
995     }
device_type( mut self, device_type: PhysicalDeviceType, ) -> PhysicalDevicePropertiesBuilder<'a>996     pub fn device_type(
997         mut self,
998         device_type: PhysicalDeviceType,
999     ) -> PhysicalDevicePropertiesBuilder<'a> {
1000         self.inner.device_type = device_type;
1001         self
1002     }
device_name( mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE], ) -> PhysicalDevicePropertiesBuilder<'a>1003     pub fn device_name(
1004         mut self,
1005         device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE],
1006     ) -> PhysicalDevicePropertiesBuilder<'a> {
1007         self.inner.device_name = device_name;
1008         self
1009     }
pipeline_cache_uuid( mut self, pipeline_cache_uuid: [u8; UUID_SIZE], ) -> PhysicalDevicePropertiesBuilder<'a>1010     pub fn pipeline_cache_uuid(
1011         mut self,
1012         pipeline_cache_uuid: [u8; UUID_SIZE],
1013     ) -> PhysicalDevicePropertiesBuilder<'a> {
1014         self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
1015         self
1016     }
limits(mut self, limits: PhysicalDeviceLimits) -> PhysicalDevicePropertiesBuilder<'a>1017     pub fn limits(mut self, limits: PhysicalDeviceLimits) -> PhysicalDevicePropertiesBuilder<'a> {
1018         self.inner.limits = limits;
1019         self
1020     }
sparse_properties( mut self, sparse_properties: PhysicalDeviceSparseProperties, ) -> PhysicalDevicePropertiesBuilder<'a>1021     pub fn sparse_properties(
1022         mut self,
1023         sparse_properties: PhysicalDeviceSparseProperties,
1024     ) -> PhysicalDevicePropertiesBuilder<'a> {
1025         self.inner.sparse_properties = sparse_properties;
1026         self
1027     }
1028     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1029     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1030     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProperties1031     pub fn build(self) -> PhysicalDeviceProperties {
1032         self.inner
1033     }
1034 }
1035 #[repr(C)]
1036 #[derive(Copy, Clone)]
1037 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtensionProperties.html>"]
1038 pub struct ExtensionProperties {
1039     pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1040     pub spec_version: u32,
1041 }
1042 impl fmt::Debug for ExtensionProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result1043     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1044         fmt.debug_struct("ExtensionProperties")
1045             .field("extension_name", &unsafe {
1046                 ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const c_char)
1047             })
1048             .field("spec_version", &self.spec_version)
1049             .finish()
1050     }
1051 }
1052 impl ::std::default::Default for ExtensionProperties {
default() -> ExtensionProperties1053     fn default() -> ExtensionProperties {
1054         ExtensionProperties {
1055             extension_name: unsafe { ::std::mem::zeroed() },
1056             spec_version: u32::default(),
1057         }
1058     }
1059 }
1060 impl ExtensionProperties {
builder<'a>() -> ExtensionPropertiesBuilder<'a>1061     pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> {
1062         ExtensionPropertiesBuilder {
1063             inner: ExtensionProperties::default(),
1064             marker: ::std::marker::PhantomData,
1065         }
1066     }
1067 }
1068 #[repr(transparent)]
1069 pub struct ExtensionPropertiesBuilder<'a> {
1070     inner: ExtensionProperties,
1071     marker: ::std::marker::PhantomData<&'a ()>,
1072 }
1073 impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> {
1074     type Target = ExtensionProperties;
deref(&self) -> &Self::Target1075     fn deref(&self) -> &Self::Target {
1076         &self.inner
1077     }
1078 }
1079 impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1080     fn deref_mut(&mut self) -> &mut Self::Target {
1081         &mut self.inner
1082     }
1083 }
1084 impl<'a> ExtensionPropertiesBuilder<'a> {
extension_name( mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], ) -> ExtensionPropertiesBuilder<'a>1085     pub fn extension_name(
1086         mut self,
1087         extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1088     ) -> ExtensionPropertiesBuilder<'a> {
1089         self.inner.extension_name = extension_name;
1090         self
1091     }
spec_version(mut self, spec_version: u32) -> ExtensionPropertiesBuilder<'a>1092     pub fn spec_version(mut self, spec_version: u32) -> ExtensionPropertiesBuilder<'a> {
1093         self.inner.spec_version = spec_version;
1094         self
1095     }
1096     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1097     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1098     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExtensionProperties1099     pub fn build(self) -> ExtensionProperties {
1100         self.inner
1101     }
1102 }
1103 #[repr(C)]
1104 #[derive(Copy, Clone)]
1105 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkLayerProperties.html>"]
1106 pub struct LayerProperties {
1107     pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1108     pub spec_version: u32,
1109     pub implementation_version: u32,
1110     pub description: [c_char; MAX_DESCRIPTION_SIZE],
1111 }
1112 impl fmt::Debug for LayerProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result1113     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1114         fmt.debug_struct("LayerProperties")
1115             .field("layer_name", &unsafe {
1116                 ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const c_char)
1117             })
1118             .field("spec_version", &self.spec_version)
1119             .field("implementation_version", &self.implementation_version)
1120             .field("description", &unsafe {
1121                 ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
1122             })
1123             .finish()
1124     }
1125 }
1126 impl ::std::default::Default for LayerProperties {
default() -> LayerProperties1127     fn default() -> LayerProperties {
1128         LayerProperties {
1129             layer_name: unsafe { ::std::mem::zeroed() },
1130             spec_version: u32::default(),
1131             implementation_version: u32::default(),
1132             description: unsafe { ::std::mem::zeroed() },
1133         }
1134     }
1135 }
1136 impl LayerProperties {
builder<'a>() -> LayerPropertiesBuilder<'a>1137     pub fn builder<'a>() -> LayerPropertiesBuilder<'a> {
1138         LayerPropertiesBuilder {
1139             inner: LayerProperties::default(),
1140             marker: ::std::marker::PhantomData,
1141         }
1142     }
1143 }
1144 #[repr(transparent)]
1145 pub struct LayerPropertiesBuilder<'a> {
1146     inner: LayerProperties,
1147     marker: ::std::marker::PhantomData<&'a ()>,
1148 }
1149 impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> {
1150     type Target = LayerProperties;
deref(&self) -> &Self::Target1151     fn deref(&self) -> &Self::Target {
1152         &self.inner
1153     }
1154 }
1155 impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1156     fn deref_mut(&mut self) -> &mut Self::Target {
1157         &mut self.inner
1158     }
1159 }
1160 impl<'a> LayerPropertiesBuilder<'a> {
layer_name( mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE], ) -> LayerPropertiesBuilder<'a>1161     pub fn layer_name(
1162         mut self,
1163         layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
1164     ) -> LayerPropertiesBuilder<'a> {
1165         self.inner.layer_name = layer_name;
1166         self
1167     }
spec_version(mut self, spec_version: u32) -> LayerPropertiesBuilder<'a>1168     pub fn spec_version(mut self, spec_version: u32) -> LayerPropertiesBuilder<'a> {
1169         self.inner.spec_version = spec_version;
1170         self
1171     }
implementation_version( mut self, implementation_version: u32, ) -> LayerPropertiesBuilder<'a>1172     pub fn implementation_version(
1173         mut self,
1174         implementation_version: u32,
1175     ) -> LayerPropertiesBuilder<'a> {
1176         self.inner.implementation_version = implementation_version;
1177         self
1178     }
description( mut self, description: [c_char; MAX_DESCRIPTION_SIZE], ) -> LayerPropertiesBuilder<'a>1179     pub fn description(
1180         mut self,
1181         description: [c_char; MAX_DESCRIPTION_SIZE],
1182     ) -> LayerPropertiesBuilder<'a> {
1183         self.inner.description = description;
1184         self
1185     }
1186     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1187     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1188     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> LayerProperties1189     pub fn build(self) -> LayerProperties {
1190         self.inner
1191     }
1192 }
1193 #[repr(C)]
1194 #[derive(Copy, Clone, Debug)]
1195 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkApplicationInfo.html>"]
1196 pub struct ApplicationInfo {
1197     pub s_type: StructureType,
1198     pub p_next: *const c_void,
1199     pub p_application_name: *const c_char,
1200     pub application_version: u32,
1201     pub p_engine_name: *const c_char,
1202     pub engine_version: u32,
1203     pub api_version: u32,
1204 }
1205 impl ::std::default::Default for ApplicationInfo {
default() -> ApplicationInfo1206     fn default() -> ApplicationInfo {
1207         ApplicationInfo {
1208             s_type: StructureType::APPLICATION_INFO,
1209             p_next: ::std::ptr::null(),
1210             p_application_name: ::std::ptr::null(),
1211             application_version: u32::default(),
1212             p_engine_name: ::std::ptr::null(),
1213             engine_version: u32::default(),
1214             api_version: u32::default(),
1215         }
1216     }
1217 }
1218 impl ApplicationInfo {
builder<'a>() -> ApplicationInfoBuilder<'a>1219     pub fn builder<'a>() -> ApplicationInfoBuilder<'a> {
1220         ApplicationInfoBuilder {
1221             inner: ApplicationInfo::default(),
1222             marker: ::std::marker::PhantomData,
1223         }
1224     }
1225 }
1226 #[repr(transparent)]
1227 pub struct ApplicationInfoBuilder<'a> {
1228     inner: ApplicationInfo,
1229     marker: ::std::marker::PhantomData<&'a ()>,
1230 }
1231 pub unsafe trait ExtendsApplicationInfo {}
1232 impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> {
1233     type Target = ApplicationInfo;
deref(&self) -> &Self::Target1234     fn deref(&self) -> &Self::Target {
1235         &self.inner
1236     }
1237 }
1238 impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1239     fn deref_mut(&mut self) -> &mut Self::Target {
1240         &mut self.inner
1241     }
1242 }
1243 impl<'a> ApplicationInfoBuilder<'a> {
application_name( mut self, application_name: &'a ::std::ffi::CStr, ) -> ApplicationInfoBuilder<'a>1244     pub fn application_name(
1245         mut self,
1246         application_name: &'a ::std::ffi::CStr,
1247     ) -> ApplicationInfoBuilder<'a> {
1248         self.inner.p_application_name = application_name.as_ptr();
1249         self
1250     }
application_version(mut self, application_version: u32) -> ApplicationInfoBuilder<'a>1251     pub fn application_version(mut self, application_version: u32) -> ApplicationInfoBuilder<'a> {
1252         self.inner.application_version = application_version;
1253         self
1254     }
engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> ApplicationInfoBuilder<'a>1255     pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> ApplicationInfoBuilder<'a> {
1256         self.inner.p_engine_name = engine_name.as_ptr();
1257         self
1258     }
engine_version(mut self, engine_version: u32) -> ApplicationInfoBuilder<'a>1259     pub fn engine_version(mut self, engine_version: u32) -> ApplicationInfoBuilder<'a> {
1260         self.inner.engine_version = engine_version;
1261         self
1262     }
api_version(mut self, api_version: u32) -> ApplicationInfoBuilder<'a>1263     pub fn api_version(mut self, api_version: u32) -> ApplicationInfoBuilder<'a> {
1264         self.inner.api_version = api_version;
1265         self
1266     }
1267     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1268     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1269     #[doc = r" valid extension structs can be pushed into the chain."]
1270     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1271     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsApplicationInfo>( mut self, next: &'a mut T, ) -> ApplicationInfoBuilder<'a>1272     pub fn push_next<T: ExtendsApplicationInfo>(
1273         mut self,
1274         next: &'a mut T,
1275     ) -> ApplicationInfoBuilder<'a> {
1276         unsafe {
1277             let next_ptr = next as *mut T as *mut BaseOutStructure;
1278             let last_next = ptr_chain_iter(next).last().unwrap();
1279             (*last_next).p_next = self.inner.p_next as _;
1280             self.inner.p_next = next_ptr as _;
1281         }
1282         self
1283     }
1284     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1285     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1286     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ApplicationInfo1287     pub fn build(self) -> ApplicationInfo {
1288         self.inner
1289     }
1290 }
1291 #[repr(C)]
1292 #[derive(Copy, Clone)]
1293 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAllocationCallbacks.html>"]
1294 pub struct AllocationCallbacks {
1295     pub p_user_data: *mut c_void,
1296     pub pfn_allocation: PFN_vkAllocationFunction,
1297     pub pfn_reallocation: PFN_vkReallocationFunction,
1298     pub pfn_free: PFN_vkFreeFunction,
1299     pub pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1300     pub pfn_internal_free: PFN_vkInternalFreeNotification,
1301 }
1302 impl fmt::Debug for AllocationCallbacks {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result1303     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1304         fmt.debug_struct("AllocationCallbacks")
1305             .field("p_user_data", &self.p_user_data)
1306             .field(
1307                 "pfn_allocation",
1308                 &(self.pfn_allocation.map(|x| x as *const ())),
1309             )
1310             .field(
1311                 "pfn_reallocation",
1312                 &(self.pfn_reallocation.map(|x| x as *const ())),
1313             )
1314             .field("pfn_free", &(self.pfn_free.map(|x| x as *const ())))
1315             .field(
1316                 "pfn_internal_allocation",
1317                 &(self.pfn_internal_allocation.map(|x| x as *const ())),
1318             )
1319             .field(
1320                 "pfn_internal_free",
1321                 &(self.pfn_internal_free.map(|x| x as *const ())),
1322             )
1323             .finish()
1324     }
1325 }
1326 impl ::std::default::Default for AllocationCallbacks {
default() -> AllocationCallbacks1327     fn default() -> AllocationCallbacks {
1328         AllocationCallbacks {
1329             p_user_data: ::std::ptr::null_mut(),
1330             pfn_allocation: PFN_vkAllocationFunction::default(),
1331             pfn_reallocation: PFN_vkReallocationFunction::default(),
1332             pfn_free: PFN_vkFreeFunction::default(),
1333             pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(),
1334             pfn_internal_free: PFN_vkInternalFreeNotification::default(),
1335         }
1336     }
1337 }
1338 impl AllocationCallbacks {
builder<'a>() -> AllocationCallbacksBuilder<'a>1339     pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> {
1340         AllocationCallbacksBuilder {
1341             inner: AllocationCallbacks::default(),
1342             marker: ::std::marker::PhantomData,
1343         }
1344     }
1345 }
1346 #[repr(transparent)]
1347 pub struct AllocationCallbacksBuilder<'a> {
1348     inner: AllocationCallbacks,
1349     marker: ::std::marker::PhantomData<&'a ()>,
1350 }
1351 impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> {
1352     type Target = AllocationCallbacks;
deref(&self) -> &Self::Target1353     fn deref(&self) -> &Self::Target {
1354         &self.inner
1355     }
1356 }
1357 impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1358     fn deref_mut(&mut self) -> &mut Self::Target {
1359         &mut self.inner
1360     }
1361 }
1362 impl<'a> AllocationCallbacksBuilder<'a> {
user_data(mut self, user_data: *mut c_void) -> AllocationCallbacksBuilder<'a>1363     pub fn user_data(mut self, user_data: *mut c_void) -> AllocationCallbacksBuilder<'a> {
1364         self.inner.p_user_data = user_data;
1365         self
1366     }
pfn_allocation( mut self, pfn_allocation: PFN_vkAllocationFunction, ) -> AllocationCallbacksBuilder<'a>1367     pub fn pfn_allocation(
1368         mut self,
1369         pfn_allocation: PFN_vkAllocationFunction,
1370     ) -> AllocationCallbacksBuilder<'a> {
1371         self.inner.pfn_allocation = pfn_allocation;
1372         self
1373     }
pfn_reallocation( mut self, pfn_reallocation: PFN_vkReallocationFunction, ) -> AllocationCallbacksBuilder<'a>1374     pub fn pfn_reallocation(
1375         mut self,
1376         pfn_reallocation: PFN_vkReallocationFunction,
1377     ) -> AllocationCallbacksBuilder<'a> {
1378         self.inner.pfn_reallocation = pfn_reallocation;
1379         self
1380     }
pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> AllocationCallbacksBuilder<'a>1381     pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> AllocationCallbacksBuilder<'a> {
1382         self.inner.pfn_free = pfn_free;
1383         self
1384     }
pfn_internal_allocation( mut self, pfn_internal_allocation: PFN_vkInternalAllocationNotification, ) -> AllocationCallbacksBuilder<'a>1385     pub fn pfn_internal_allocation(
1386         mut self,
1387         pfn_internal_allocation: PFN_vkInternalAllocationNotification,
1388     ) -> AllocationCallbacksBuilder<'a> {
1389         self.inner.pfn_internal_allocation = pfn_internal_allocation;
1390         self
1391     }
pfn_internal_free( mut self, pfn_internal_free: PFN_vkInternalFreeNotification, ) -> AllocationCallbacksBuilder<'a>1392     pub fn pfn_internal_free(
1393         mut self,
1394         pfn_internal_free: PFN_vkInternalFreeNotification,
1395     ) -> AllocationCallbacksBuilder<'a> {
1396         self.inner.pfn_internal_free = pfn_internal_free;
1397         self
1398     }
1399     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1400     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1401     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AllocationCallbacks1402     pub fn build(self) -> AllocationCallbacks {
1403         self.inner
1404     }
1405 }
1406 #[repr(C)]
1407 #[derive(Copy, Clone, Debug)]
1408 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateInfo.html>"]
1409 pub struct DeviceQueueCreateInfo {
1410     pub s_type: StructureType,
1411     pub p_next: *const c_void,
1412     pub flags: DeviceQueueCreateFlags,
1413     pub queue_family_index: u32,
1414     pub queue_count: u32,
1415     pub p_queue_priorities: *const f32,
1416 }
1417 impl ::std::default::Default for DeviceQueueCreateInfo {
default() -> DeviceQueueCreateInfo1418     fn default() -> DeviceQueueCreateInfo {
1419         DeviceQueueCreateInfo {
1420             s_type: StructureType::DEVICE_QUEUE_CREATE_INFO,
1421             p_next: ::std::ptr::null(),
1422             flags: DeviceQueueCreateFlags::default(),
1423             queue_family_index: u32::default(),
1424             queue_count: u32::default(),
1425             p_queue_priorities: ::std::ptr::null(),
1426         }
1427     }
1428 }
1429 impl DeviceQueueCreateInfo {
builder<'a>() -> DeviceQueueCreateInfoBuilder<'a>1430     pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> {
1431         DeviceQueueCreateInfoBuilder {
1432             inner: DeviceQueueCreateInfo::default(),
1433             marker: ::std::marker::PhantomData,
1434         }
1435     }
1436 }
1437 #[repr(transparent)]
1438 pub struct DeviceQueueCreateInfoBuilder<'a> {
1439     inner: DeviceQueueCreateInfo,
1440     marker: ::std::marker::PhantomData<&'a ()>,
1441 }
1442 pub unsafe trait ExtendsDeviceQueueCreateInfo {}
1443 impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> {
1444     type Target = DeviceQueueCreateInfo;
deref(&self) -> &Self::Target1445     fn deref(&self) -> &Self::Target {
1446         &self.inner
1447     }
1448 }
1449 impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1450     fn deref_mut(&mut self) -> &mut Self::Target {
1451         &mut self.inner
1452     }
1453 }
1454 impl<'a> DeviceQueueCreateInfoBuilder<'a> {
flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueCreateInfoBuilder<'a>1455     pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueCreateInfoBuilder<'a> {
1456         self.inner.flags = flags;
1457         self
1458     }
queue_family_index( mut self, queue_family_index: u32, ) -> DeviceQueueCreateInfoBuilder<'a>1459     pub fn queue_family_index(
1460         mut self,
1461         queue_family_index: u32,
1462     ) -> DeviceQueueCreateInfoBuilder<'a> {
1463         self.inner.queue_family_index = queue_family_index;
1464         self
1465     }
queue_priorities( mut self, queue_priorities: &'a [f32], ) -> DeviceQueueCreateInfoBuilder<'a>1466     pub fn queue_priorities(
1467         mut self,
1468         queue_priorities: &'a [f32],
1469     ) -> DeviceQueueCreateInfoBuilder<'a> {
1470         self.inner.queue_count = queue_priorities.len() as _;
1471         self.inner.p_queue_priorities = queue_priorities.as_ptr();
1472         self
1473     }
1474     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1475     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1476     #[doc = r" valid extension structs can be pushed into the chain."]
1477     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1478     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceQueueCreateInfo>( mut self, next: &'a mut T, ) -> DeviceQueueCreateInfoBuilder<'a>1479     pub fn push_next<T: ExtendsDeviceQueueCreateInfo>(
1480         mut self,
1481         next: &'a mut T,
1482     ) -> DeviceQueueCreateInfoBuilder<'a> {
1483         unsafe {
1484             let next_ptr = next as *mut T as *mut BaseOutStructure;
1485             let last_next = ptr_chain_iter(next).last().unwrap();
1486             (*last_next).p_next = self.inner.p_next as _;
1487             self.inner.p_next = next_ptr as _;
1488         }
1489         self
1490     }
1491     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1492     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1493     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceQueueCreateInfo1494     pub fn build(self) -> DeviceQueueCreateInfo {
1495         self.inner
1496     }
1497 }
1498 #[repr(C)]
1499 #[derive(Copy, Clone, Debug)]
1500 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateInfo.html>"]
1501 pub struct DeviceCreateInfo {
1502     pub s_type: StructureType,
1503     pub p_next: *const c_void,
1504     pub flags: DeviceCreateFlags,
1505     pub queue_create_info_count: u32,
1506     pub p_queue_create_infos: *const DeviceQueueCreateInfo,
1507     pub enabled_layer_count: u32,
1508     pub pp_enabled_layer_names: *const *const c_char,
1509     pub enabled_extension_count: u32,
1510     pub pp_enabled_extension_names: *const *const c_char,
1511     pub p_enabled_features: *const PhysicalDeviceFeatures,
1512 }
1513 impl ::std::default::Default for DeviceCreateInfo {
default() -> DeviceCreateInfo1514     fn default() -> DeviceCreateInfo {
1515         DeviceCreateInfo {
1516             s_type: StructureType::DEVICE_CREATE_INFO,
1517             p_next: ::std::ptr::null(),
1518             flags: DeviceCreateFlags::default(),
1519             queue_create_info_count: u32::default(),
1520             p_queue_create_infos: ::std::ptr::null(),
1521             enabled_layer_count: u32::default(),
1522             pp_enabled_layer_names: ::std::ptr::null(),
1523             enabled_extension_count: u32::default(),
1524             pp_enabled_extension_names: ::std::ptr::null(),
1525             p_enabled_features: ::std::ptr::null(),
1526         }
1527     }
1528 }
1529 impl DeviceCreateInfo {
builder<'a>() -> DeviceCreateInfoBuilder<'a>1530     pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> {
1531         DeviceCreateInfoBuilder {
1532             inner: DeviceCreateInfo::default(),
1533             marker: ::std::marker::PhantomData,
1534         }
1535     }
1536 }
1537 #[repr(transparent)]
1538 pub struct DeviceCreateInfoBuilder<'a> {
1539     inner: DeviceCreateInfo,
1540     marker: ::std::marker::PhantomData<&'a ()>,
1541 }
1542 pub unsafe trait ExtendsDeviceCreateInfo {}
1543 impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> {
1544     type Target = DeviceCreateInfo;
deref(&self) -> &Self::Target1545     fn deref(&self) -> &Self::Target {
1546         &self.inner
1547     }
1548 }
1549 impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1550     fn deref_mut(&mut self) -> &mut Self::Target {
1551         &mut self.inner
1552     }
1553 }
1554 impl<'a> DeviceCreateInfoBuilder<'a> {
flags(mut self, flags: DeviceCreateFlags) -> DeviceCreateInfoBuilder<'a>1555     pub fn flags(mut self, flags: DeviceCreateFlags) -> DeviceCreateInfoBuilder<'a> {
1556         self.inner.flags = flags;
1557         self
1558     }
queue_create_infos( mut self, queue_create_infos: &'a [DeviceQueueCreateInfo], ) -> DeviceCreateInfoBuilder<'a>1559     pub fn queue_create_infos(
1560         mut self,
1561         queue_create_infos: &'a [DeviceQueueCreateInfo],
1562     ) -> DeviceCreateInfoBuilder<'a> {
1563         self.inner.queue_create_info_count = queue_create_infos.len() as _;
1564         self.inner.p_queue_create_infos = queue_create_infos.as_ptr();
1565         self
1566     }
enabled_layer_names( mut self, enabled_layer_names: &'a [*const c_char], ) -> DeviceCreateInfoBuilder<'a>1567     pub fn enabled_layer_names(
1568         mut self,
1569         enabled_layer_names: &'a [*const c_char],
1570     ) -> DeviceCreateInfoBuilder<'a> {
1571         self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1572         self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1573         self
1574     }
enabled_extension_names( mut self, enabled_extension_names: &'a [*const c_char], ) -> DeviceCreateInfoBuilder<'a>1575     pub fn enabled_extension_names(
1576         mut self,
1577         enabled_extension_names: &'a [*const c_char],
1578     ) -> DeviceCreateInfoBuilder<'a> {
1579         self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1580         self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1581         self
1582     }
enabled_features( mut self, enabled_features: &'a PhysicalDeviceFeatures, ) -> DeviceCreateInfoBuilder<'a>1583     pub fn enabled_features(
1584         mut self,
1585         enabled_features: &'a PhysicalDeviceFeatures,
1586     ) -> DeviceCreateInfoBuilder<'a> {
1587         self.inner.p_enabled_features = enabled_features;
1588         self
1589     }
1590     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1591     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1592     #[doc = r" valid extension structs can be pushed into the chain."]
1593     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1594     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceCreateInfo>( mut self, next: &'a mut T, ) -> DeviceCreateInfoBuilder<'a>1595     pub fn push_next<T: ExtendsDeviceCreateInfo>(
1596         mut self,
1597         next: &'a mut T,
1598     ) -> DeviceCreateInfoBuilder<'a> {
1599         unsafe {
1600             let next_ptr = next as *mut T as *mut BaseOutStructure;
1601             let last_next = ptr_chain_iter(next).last().unwrap();
1602             (*last_next).p_next = self.inner.p_next as _;
1603             self.inner.p_next = next_ptr as _;
1604         }
1605         self
1606     }
1607     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1608     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1609     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceCreateInfo1610     pub fn build(self) -> DeviceCreateInfo {
1611         self.inner
1612     }
1613 }
1614 #[repr(C)]
1615 #[derive(Copy, Clone, Debug)]
1616 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateInfo.html>"]
1617 pub struct InstanceCreateInfo {
1618     pub s_type: StructureType,
1619     pub p_next: *const c_void,
1620     pub flags: InstanceCreateFlags,
1621     pub p_application_info: *const ApplicationInfo,
1622     pub enabled_layer_count: u32,
1623     pub pp_enabled_layer_names: *const *const c_char,
1624     pub enabled_extension_count: u32,
1625     pub pp_enabled_extension_names: *const *const c_char,
1626 }
1627 impl ::std::default::Default for InstanceCreateInfo {
default() -> InstanceCreateInfo1628     fn default() -> InstanceCreateInfo {
1629         InstanceCreateInfo {
1630             s_type: StructureType::INSTANCE_CREATE_INFO,
1631             p_next: ::std::ptr::null(),
1632             flags: InstanceCreateFlags::default(),
1633             p_application_info: ::std::ptr::null(),
1634             enabled_layer_count: u32::default(),
1635             pp_enabled_layer_names: ::std::ptr::null(),
1636             enabled_extension_count: u32::default(),
1637             pp_enabled_extension_names: ::std::ptr::null(),
1638         }
1639     }
1640 }
1641 impl InstanceCreateInfo {
builder<'a>() -> InstanceCreateInfoBuilder<'a>1642     pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> {
1643         InstanceCreateInfoBuilder {
1644             inner: InstanceCreateInfo::default(),
1645             marker: ::std::marker::PhantomData,
1646         }
1647     }
1648 }
1649 #[repr(transparent)]
1650 pub struct InstanceCreateInfoBuilder<'a> {
1651     inner: InstanceCreateInfo,
1652     marker: ::std::marker::PhantomData<&'a ()>,
1653 }
1654 pub unsafe trait ExtendsInstanceCreateInfo {}
1655 impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> {
1656     type Target = InstanceCreateInfo;
deref(&self) -> &Self::Target1657     fn deref(&self) -> &Self::Target {
1658         &self.inner
1659     }
1660 }
1661 impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1662     fn deref_mut(&mut self) -> &mut Self::Target {
1663         &mut self.inner
1664     }
1665 }
1666 impl<'a> InstanceCreateInfoBuilder<'a> {
flags(mut self, flags: InstanceCreateFlags) -> InstanceCreateInfoBuilder<'a>1667     pub fn flags(mut self, flags: InstanceCreateFlags) -> InstanceCreateInfoBuilder<'a> {
1668         self.inner.flags = flags;
1669         self
1670     }
application_info( mut self, application_info: &'a ApplicationInfo, ) -> InstanceCreateInfoBuilder<'a>1671     pub fn application_info(
1672         mut self,
1673         application_info: &'a ApplicationInfo,
1674     ) -> InstanceCreateInfoBuilder<'a> {
1675         self.inner.p_application_info = application_info;
1676         self
1677     }
enabled_layer_names( mut self, enabled_layer_names: &'a [*const c_char], ) -> InstanceCreateInfoBuilder<'a>1678     pub fn enabled_layer_names(
1679         mut self,
1680         enabled_layer_names: &'a [*const c_char],
1681     ) -> InstanceCreateInfoBuilder<'a> {
1682         self.inner.enabled_layer_count = enabled_layer_names.len() as _;
1683         self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
1684         self
1685     }
enabled_extension_names( mut self, enabled_extension_names: &'a [*const c_char], ) -> InstanceCreateInfoBuilder<'a>1686     pub fn enabled_extension_names(
1687         mut self,
1688         enabled_extension_names: &'a [*const c_char],
1689     ) -> InstanceCreateInfoBuilder<'a> {
1690         self.inner.enabled_extension_count = enabled_extension_names.len() as _;
1691         self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
1692         self
1693     }
1694     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1695     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1696     #[doc = r" valid extension structs can be pushed into the chain."]
1697     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1698     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsInstanceCreateInfo>( mut self, next: &'a mut T, ) -> InstanceCreateInfoBuilder<'a>1699     pub fn push_next<T: ExtendsInstanceCreateInfo>(
1700         mut self,
1701         next: &'a mut T,
1702     ) -> InstanceCreateInfoBuilder<'a> {
1703         unsafe {
1704             let next_ptr = next as *mut T as *mut BaseOutStructure;
1705             let last_next = ptr_chain_iter(next).last().unwrap();
1706             (*last_next).p_next = self.inner.p_next as _;
1707             self.inner.p_next = next_ptr as _;
1708         }
1709         self
1710     }
1711     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1712     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1713     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> InstanceCreateInfo1714     pub fn build(self) -> InstanceCreateInfo {
1715         self.inner
1716     }
1717 }
1718 #[repr(C)]
1719 #[derive(Copy, Clone, Default, Debug)]
1720 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyProperties.html>"]
1721 pub struct QueueFamilyProperties {
1722     pub queue_flags: QueueFlags,
1723     pub queue_count: u32,
1724     pub timestamp_valid_bits: u32,
1725     pub min_image_transfer_granularity: Extent3D,
1726 }
1727 impl QueueFamilyProperties {
builder<'a>() -> QueueFamilyPropertiesBuilder<'a>1728     pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> {
1729         QueueFamilyPropertiesBuilder {
1730             inner: QueueFamilyProperties::default(),
1731             marker: ::std::marker::PhantomData,
1732         }
1733     }
1734 }
1735 #[repr(transparent)]
1736 pub struct QueueFamilyPropertiesBuilder<'a> {
1737     inner: QueueFamilyProperties,
1738     marker: ::std::marker::PhantomData<&'a ()>,
1739 }
1740 impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> {
1741     type Target = QueueFamilyProperties;
deref(&self) -> &Self::Target1742     fn deref(&self) -> &Self::Target {
1743         &self.inner
1744     }
1745 }
1746 impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1747     fn deref_mut(&mut self) -> &mut Self::Target {
1748         &mut self.inner
1749     }
1750 }
1751 impl<'a> QueueFamilyPropertiesBuilder<'a> {
queue_flags(mut self, queue_flags: QueueFlags) -> QueueFamilyPropertiesBuilder<'a>1752     pub fn queue_flags(mut self, queue_flags: QueueFlags) -> QueueFamilyPropertiesBuilder<'a> {
1753         self.inner.queue_flags = queue_flags;
1754         self
1755     }
queue_count(mut self, queue_count: u32) -> QueueFamilyPropertiesBuilder<'a>1756     pub fn queue_count(mut self, queue_count: u32) -> QueueFamilyPropertiesBuilder<'a> {
1757         self.inner.queue_count = queue_count;
1758         self
1759     }
timestamp_valid_bits( mut self, timestamp_valid_bits: u32, ) -> QueueFamilyPropertiesBuilder<'a>1760     pub fn timestamp_valid_bits(
1761         mut self,
1762         timestamp_valid_bits: u32,
1763     ) -> QueueFamilyPropertiesBuilder<'a> {
1764         self.inner.timestamp_valid_bits = timestamp_valid_bits;
1765         self
1766     }
min_image_transfer_granularity( mut self, min_image_transfer_granularity: Extent3D, ) -> QueueFamilyPropertiesBuilder<'a>1767     pub fn min_image_transfer_granularity(
1768         mut self,
1769         min_image_transfer_granularity: Extent3D,
1770     ) -> QueueFamilyPropertiesBuilder<'a> {
1771         self.inner.min_image_transfer_granularity = min_image_transfer_granularity;
1772         self
1773     }
1774     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1775     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1776     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyProperties1777     pub fn build(self) -> QueueFamilyProperties {
1778         self.inner
1779     }
1780 }
1781 #[repr(C)]
1782 #[derive(Copy, Clone, Debug)]
1783 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryProperties.html>"]
1784 pub struct PhysicalDeviceMemoryProperties {
1785     pub memory_type_count: u32,
1786     pub memory_types: [MemoryType; MAX_MEMORY_TYPES],
1787     pub memory_heap_count: u32,
1788     pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
1789 }
1790 impl ::std::default::Default for PhysicalDeviceMemoryProperties {
default() -> PhysicalDeviceMemoryProperties1791     fn default() -> PhysicalDeviceMemoryProperties {
1792         PhysicalDeviceMemoryProperties {
1793             memory_type_count: u32::default(),
1794             memory_types: unsafe { ::std::mem::zeroed() },
1795             memory_heap_count: u32::default(),
1796             memory_heaps: unsafe { ::std::mem::zeroed() },
1797         }
1798     }
1799 }
1800 impl PhysicalDeviceMemoryProperties {
builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a>1801     pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1802         PhysicalDeviceMemoryPropertiesBuilder {
1803             inner: PhysicalDeviceMemoryProperties::default(),
1804             marker: ::std::marker::PhantomData,
1805         }
1806     }
1807 }
1808 #[repr(transparent)]
1809 pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> {
1810     inner: PhysicalDeviceMemoryProperties,
1811     marker: ::std::marker::PhantomData<&'a ()>,
1812 }
1813 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> {
1814     type Target = PhysicalDeviceMemoryProperties;
deref(&self) -> &Self::Target1815     fn deref(&self) -> &Self::Target {
1816         &self.inner
1817     }
1818 }
1819 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1820     fn deref_mut(&mut self) -> &mut Self::Target {
1821         &mut self.inner
1822     }
1823 }
1824 impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
memory_type_count( mut self, memory_type_count: u32, ) -> PhysicalDeviceMemoryPropertiesBuilder<'a>1825     pub fn memory_type_count(
1826         mut self,
1827         memory_type_count: u32,
1828     ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1829         self.inner.memory_type_count = memory_type_count;
1830         self
1831     }
memory_types( mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES], ) -> PhysicalDeviceMemoryPropertiesBuilder<'a>1832     pub fn memory_types(
1833         mut self,
1834         memory_types: [MemoryType; MAX_MEMORY_TYPES],
1835     ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1836         self.inner.memory_types = memory_types;
1837         self
1838     }
memory_heap_count( mut self, memory_heap_count: u32, ) -> PhysicalDeviceMemoryPropertiesBuilder<'a>1839     pub fn memory_heap_count(
1840         mut self,
1841         memory_heap_count: u32,
1842     ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1843         self.inner.memory_heap_count = memory_heap_count;
1844         self
1845     }
memory_heaps( mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], ) -> PhysicalDeviceMemoryPropertiesBuilder<'a>1846     pub fn memory_heaps(
1847         mut self,
1848         memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
1849     ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
1850         self.inner.memory_heaps = memory_heaps;
1851         self
1852     }
1853     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1854     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1855     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryProperties1856     pub fn build(self) -> PhysicalDeviceMemoryProperties {
1857         self.inner
1858     }
1859 }
1860 #[repr(C)]
1861 #[derive(Copy, Clone, Debug)]
1862 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateInfo.html>"]
1863 pub struct MemoryAllocateInfo {
1864     pub s_type: StructureType,
1865     pub p_next: *const c_void,
1866     pub allocation_size: DeviceSize,
1867     pub memory_type_index: u32,
1868 }
1869 impl ::std::default::Default for MemoryAllocateInfo {
default() -> MemoryAllocateInfo1870     fn default() -> MemoryAllocateInfo {
1871         MemoryAllocateInfo {
1872             s_type: StructureType::MEMORY_ALLOCATE_INFO,
1873             p_next: ::std::ptr::null(),
1874             allocation_size: DeviceSize::default(),
1875             memory_type_index: u32::default(),
1876         }
1877     }
1878 }
1879 impl MemoryAllocateInfo {
builder<'a>() -> MemoryAllocateInfoBuilder<'a>1880     pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> {
1881         MemoryAllocateInfoBuilder {
1882             inner: MemoryAllocateInfo::default(),
1883             marker: ::std::marker::PhantomData,
1884         }
1885     }
1886 }
1887 #[repr(transparent)]
1888 pub struct MemoryAllocateInfoBuilder<'a> {
1889     inner: MemoryAllocateInfo,
1890     marker: ::std::marker::PhantomData<&'a ()>,
1891 }
1892 pub unsafe trait ExtendsMemoryAllocateInfo {}
1893 impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> {
1894     type Target = MemoryAllocateInfo;
deref(&self) -> &Self::Target1895     fn deref(&self) -> &Self::Target {
1896         &self.inner
1897     }
1898 }
1899 impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1900     fn deref_mut(&mut self) -> &mut Self::Target {
1901         &mut self.inner
1902     }
1903 }
1904 impl<'a> MemoryAllocateInfoBuilder<'a> {
allocation_size(mut self, allocation_size: DeviceSize) -> MemoryAllocateInfoBuilder<'a>1905     pub fn allocation_size(mut self, allocation_size: DeviceSize) -> MemoryAllocateInfoBuilder<'a> {
1906         self.inner.allocation_size = allocation_size;
1907         self
1908     }
memory_type_index(mut self, memory_type_index: u32) -> MemoryAllocateInfoBuilder<'a>1909     pub fn memory_type_index(mut self, memory_type_index: u32) -> MemoryAllocateInfoBuilder<'a> {
1910         self.inner.memory_type_index = memory_type_index;
1911         self
1912     }
1913     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
1914     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
1915     #[doc = r" valid extension structs can be pushed into the chain."]
1916     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
1917     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryAllocateInfo>( mut self, next: &'a mut T, ) -> MemoryAllocateInfoBuilder<'a>1918     pub fn push_next<T: ExtendsMemoryAllocateInfo>(
1919         mut self,
1920         next: &'a mut T,
1921     ) -> MemoryAllocateInfoBuilder<'a> {
1922         unsafe {
1923             let next_ptr = next as *mut T as *mut BaseOutStructure;
1924             let last_next = ptr_chain_iter(next).last().unwrap();
1925             (*last_next).p_next = self.inner.p_next as _;
1926             self.inner.p_next = next_ptr as _;
1927         }
1928         self
1929     }
1930     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1931     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1932     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryAllocateInfo1933     pub fn build(self) -> MemoryAllocateInfo {
1934         self.inner
1935     }
1936 }
1937 #[repr(C)]
1938 #[derive(Copy, Clone, Default, Debug)]
1939 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryRequirements.html>"]
1940 pub struct MemoryRequirements {
1941     pub size: DeviceSize,
1942     pub alignment: DeviceSize,
1943     pub memory_type_bits: u32,
1944 }
1945 impl MemoryRequirements {
builder<'a>() -> MemoryRequirementsBuilder<'a>1946     pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> {
1947         MemoryRequirementsBuilder {
1948             inner: MemoryRequirements::default(),
1949             marker: ::std::marker::PhantomData,
1950         }
1951     }
1952 }
1953 #[repr(transparent)]
1954 pub struct MemoryRequirementsBuilder<'a> {
1955     inner: MemoryRequirements,
1956     marker: ::std::marker::PhantomData<&'a ()>,
1957 }
1958 impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> {
1959     type Target = MemoryRequirements;
deref(&self) -> &Self::Target1960     fn deref(&self) -> &Self::Target {
1961         &self.inner
1962     }
1963 }
1964 impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target1965     fn deref_mut(&mut self) -> &mut Self::Target {
1966         &mut self.inner
1967     }
1968 }
1969 impl<'a> MemoryRequirementsBuilder<'a> {
size(mut self, size: DeviceSize) -> MemoryRequirementsBuilder<'a>1970     pub fn size(mut self, size: DeviceSize) -> MemoryRequirementsBuilder<'a> {
1971         self.inner.size = size;
1972         self
1973     }
alignment(mut self, alignment: DeviceSize) -> MemoryRequirementsBuilder<'a>1974     pub fn alignment(mut self, alignment: DeviceSize) -> MemoryRequirementsBuilder<'a> {
1975         self.inner.alignment = alignment;
1976         self
1977     }
memory_type_bits(mut self, memory_type_bits: u32) -> MemoryRequirementsBuilder<'a>1978     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> MemoryRequirementsBuilder<'a> {
1979         self.inner.memory_type_bits = memory_type_bits;
1980         self
1981     }
1982     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
1983     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
1984     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryRequirements1985     pub fn build(self) -> MemoryRequirements {
1986         self.inner
1987     }
1988 }
1989 #[repr(C)]
1990 #[derive(Copy, Clone, Default, Debug)]
1991 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatProperties.html>"]
1992 pub struct SparseImageFormatProperties {
1993     pub aspect_mask: ImageAspectFlags,
1994     pub image_granularity: Extent3D,
1995     pub flags: SparseImageFormatFlags,
1996 }
1997 impl SparseImageFormatProperties {
builder<'a>() -> SparseImageFormatPropertiesBuilder<'a>1998     pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> {
1999         SparseImageFormatPropertiesBuilder {
2000             inner: SparseImageFormatProperties::default(),
2001             marker: ::std::marker::PhantomData,
2002         }
2003     }
2004 }
2005 #[repr(transparent)]
2006 pub struct SparseImageFormatPropertiesBuilder<'a> {
2007     inner: SparseImageFormatProperties,
2008     marker: ::std::marker::PhantomData<&'a ()>,
2009 }
2010 impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> {
2011     type Target = SparseImageFormatProperties;
deref(&self) -> &Self::Target2012     fn deref(&self) -> &Self::Target {
2013         &self.inner
2014     }
2015 }
2016 impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2017     fn deref_mut(&mut self) -> &mut Self::Target {
2018         &mut self.inner
2019     }
2020 }
2021 impl<'a> SparseImageFormatPropertiesBuilder<'a> {
aspect_mask( mut self, aspect_mask: ImageAspectFlags, ) -> SparseImageFormatPropertiesBuilder<'a>2022     pub fn aspect_mask(
2023         mut self,
2024         aspect_mask: ImageAspectFlags,
2025     ) -> SparseImageFormatPropertiesBuilder<'a> {
2026         self.inner.aspect_mask = aspect_mask;
2027         self
2028     }
image_granularity( mut self, image_granularity: Extent3D, ) -> SparseImageFormatPropertiesBuilder<'a>2029     pub fn image_granularity(
2030         mut self,
2031         image_granularity: Extent3D,
2032     ) -> SparseImageFormatPropertiesBuilder<'a> {
2033         self.inner.image_granularity = image_granularity;
2034         self
2035     }
flags( mut self, flags: SparseImageFormatFlags, ) -> SparseImageFormatPropertiesBuilder<'a>2036     pub fn flags(
2037         mut self,
2038         flags: SparseImageFormatFlags,
2039     ) -> SparseImageFormatPropertiesBuilder<'a> {
2040         self.inner.flags = flags;
2041         self
2042     }
2043     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2044     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2045     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageFormatProperties2046     pub fn build(self) -> SparseImageFormatProperties {
2047         self.inner
2048     }
2049 }
2050 #[repr(C)]
2051 #[derive(Copy, Clone, Default, Debug)]
2052 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryRequirements.html>"]
2053 pub struct SparseImageMemoryRequirements {
2054     pub format_properties: SparseImageFormatProperties,
2055     pub image_mip_tail_first_lod: u32,
2056     pub image_mip_tail_size: DeviceSize,
2057     pub image_mip_tail_offset: DeviceSize,
2058     pub image_mip_tail_stride: DeviceSize,
2059 }
2060 impl SparseImageMemoryRequirements {
builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a>2061     pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> {
2062         SparseImageMemoryRequirementsBuilder {
2063             inner: SparseImageMemoryRequirements::default(),
2064             marker: ::std::marker::PhantomData,
2065         }
2066     }
2067 }
2068 #[repr(transparent)]
2069 pub struct SparseImageMemoryRequirementsBuilder<'a> {
2070     inner: SparseImageMemoryRequirements,
2071     marker: ::std::marker::PhantomData<&'a ()>,
2072 }
2073 impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> {
2074     type Target = SparseImageMemoryRequirements;
deref(&self) -> &Self::Target2075     fn deref(&self) -> &Self::Target {
2076         &self.inner
2077     }
2078 }
2079 impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2080     fn deref_mut(&mut self) -> &mut Self::Target {
2081         &mut self.inner
2082     }
2083 }
2084 impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
format_properties( mut self, format_properties: SparseImageFormatProperties, ) -> SparseImageMemoryRequirementsBuilder<'a>2085     pub fn format_properties(
2086         mut self,
2087         format_properties: SparseImageFormatProperties,
2088     ) -> SparseImageMemoryRequirementsBuilder<'a> {
2089         self.inner.format_properties = format_properties;
2090         self
2091     }
image_mip_tail_first_lod( mut self, image_mip_tail_first_lod: u32, ) -> SparseImageMemoryRequirementsBuilder<'a>2092     pub fn image_mip_tail_first_lod(
2093         mut self,
2094         image_mip_tail_first_lod: u32,
2095     ) -> SparseImageMemoryRequirementsBuilder<'a> {
2096         self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod;
2097         self
2098     }
image_mip_tail_size( mut self, image_mip_tail_size: DeviceSize, ) -> SparseImageMemoryRequirementsBuilder<'a>2099     pub fn image_mip_tail_size(
2100         mut self,
2101         image_mip_tail_size: DeviceSize,
2102     ) -> SparseImageMemoryRequirementsBuilder<'a> {
2103         self.inner.image_mip_tail_size = image_mip_tail_size;
2104         self
2105     }
image_mip_tail_offset( mut self, image_mip_tail_offset: DeviceSize, ) -> SparseImageMemoryRequirementsBuilder<'a>2106     pub fn image_mip_tail_offset(
2107         mut self,
2108         image_mip_tail_offset: DeviceSize,
2109     ) -> SparseImageMemoryRequirementsBuilder<'a> {
2110         self.inner.image_mip_tail_offset = image_mip_tail_offset;
2111         self
2112     }
image_mip_tail_stride( mut self, image_mip_tail_stride: DeviceSize, ) -> SparseImageMemoryRequirementsBuilder<'a>2113     pub fn image_mip_tail_stride(
2114         mut self,
2115         image_mip_tail_stride: DeviceSize,
2116     ) -> SparseImageMemoryRequirementsBuilder<'a> {
2117         self.inner.image_mip_tail_stride = image_mip_tail_stride;
2118         self
2119     }
2120     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2121     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2122     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryRequirements2123     pub fn build(self) -> SparseImageMemoryRequirements {
2124         self.inner
2125     }
2126 }
2127 #[repr(C)]
2128 #[derive(Copy, Clone, Default, Debug)]
2129 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryType.html>"]
2130 pub struct MemoryType {
2131     pub property_flags: MemoryPropertyFlags,
2132     pub heap_index: u32,
2133 }
2134 impl MemoryType {
builder<'a>() -> MemoryTypeBuilder<'a>2135     pub fn builder<'a>() -> MemoryTypeBuilder<'a> {
2136         MemoryTypeBuilder {
2137             inner: MemoryType::default(),
2138             marker: ::std::marker::PhantomData,
2139         }
2140     }
2141 }
2142 #[repr(transparent)]
2143 pub struct MemoryTypeBuilder<'a> {
2144     inner: MemoryType,
2145     marker: ::std::marker::PhantomData<&'a ()>,
2146 }
2147 impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> {
2148     type Target = MemoryType;
deref(&self) -> &Self::Target2149     fn deref(&self) -> &Self::Target {
2150         &self.inner
2151     }
2152 }
2153 impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2154     fn deref_mut(&mut self) -> &mut Self::Target {
2155         &mut self.inner
2156     }
2157 }
2158 impl<'a> MemoryTypeBuilder<'a> {
property_flags(mut self, property_flags: MemoryPropertyFlags) -> MemoryTypeBuilder<'a>2159     pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> MemoryTypeBuilder<'a> {
2160         self.inner.property_flags = property_flags;
2161         self
2162     }
heap_index(mut self, heap_index: u32) -> MemoryTypeBuilder<'a>2163     pub fn heap_index(mut self, heap_index: u32) -> MemoryTypeBuilder<'a> {
2164         self.inner.heap_index = heap_index;
2165         self
2166     }
2167     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2168     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2169     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryType2170     pub fn build(self) -> MemoryType {
2171         self.inner
2172     }
2173 }
2174 #[repr(C)]
2175 #[derive(Copy, Clone, Default, Debug)]
2176 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeap.html>"]
2177 pub struct MemoryHeap {
2178     pub size: DeviceSize,
2179     pub flags: MemoryHeapFlags,
2180 }
2181 impl MemoryHeap {
builder<'a>() -> MemoryHeapBuilder<'a>2182     pub fn builder<'a>() -> MemoryHeapBuilder<'a> {
2183         MemoryHeapBuilder {
2184             inner: MemoryHeap::default(),
2185             marker: ::std::marker::PhantomData,
2186         }
2187     }
2188 }
2189 #[repr(transparent)]
2190 pub struct MemoryHeapBuilder<'a> {
2191     inner: MemoryHeap,
2192     marker: ::std::marker::PhantomData<&'a ()>,
2193 }
2194 impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> {
2195     type Target = MemoryHeap;
deref(&self) -> &Self::Target2196     fn deref(&self) -> &Self::Target {
2197         &self.inner
2198     }
2199 }
2200 impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2201     fn deref_mut(&mut self) -> &mut Self::Target {
2202         &mut self.inner
2203     }
2204 }
2205 impl<'a> MemoryHeapBuilder<'a> {
size(mut self, size: DeviceSize) -> MemoryHeapBuilder<'a>2206     pub fn size(mut self, size: DeviceSize) -> MemoryHeapBuilder<'a> {
2207         self.inner.size = size;
2208         self
2209     }
flags(mut self, flags: MemoryHeapFlags) -> MemoryHeapBuilder<'a>2210     pub fn flags(mut self, flags: MemoryHeapFlags) -> MemoryHeapBuilder<'a> {
2211         self.inner.flags = flags;
2212         self
2213     }
2214     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2215     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2216     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryHeap2217     pub fn build(self) -> MemoryHeap {
2218         self.inner
2219     }
2220 }
2221 #[repr(C)]
2222 #[derive(Copy, Clone, Debug)]
2223 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMappedMemoryRange.html>"]
2224 pub struct MappedMemoryRange {
2225     pub s_type: StructureType,
2226     pub p_next: *const c_void,
2227     pub memory: DeviceMemory,
2228     pub offset: DeviceSize,
2229     pub size: DeviceSize,
2230 }
2231 impl ::std::default::Default for MappedMemoryRange {
default() -> MappedMemoryRange2232     fn default() -> MappedMemoryRange {
2233         MappedMemoryRange {
2234             s_type: StructureType::MAPPED_MEMORY_RANGE,
2235             p_next: ::std::ptr::null(),
2236             memory: DeviceMemory::default(),
2237             offset: DeviceSize::default(),
2238             size: DeviceSize::default(),
2239         }
2240     }
2241 }
2242 impl MappedMemoryRange {
builder<'a>() -> MappedMemoryRangeBuilder<'a>2243     pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> {
2244         MappedMemoryRangeBuilder {
2245             inner: MappedMemoryRange::default(),
2246             marker: ::std::marker::PhantomData,
2247         }
2248     }
2249 }
2250 #[repr(transparent)]
2251 pub struct MappedMemoryRangeBuilder<'a> {
2252     inner: MappedMemoryRange,
2253     marker: ::std::marker::PhantomData<&'a ()>,
2254 }
2255 pub unsafe trait ExtendsMappedMemoryRange {}
2256 impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> {
2257     type Target = MappedMemoryRange;
deref(&self) -> &Self::Target2258     fn deref(&self) -> &Self::Target {
2259         &self.inner
2260     }
2261 }
2262 impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2263     fn deref_mut(&mut self) -> &mut Self::Target {
2264         &mut self.inner
2265     }
2266 }
2267 impl<'a> MappedMemoryRangeBuilder<'a> {
memory(mut self, memory: DeviceMemory) -> MappedMemoryRangeBuilder<'a>2268     pub fn memory(mut self, memory: DeviceMemory) -> MappedMemoryRangeBuilder<'a> {
2269         self.inner.memory = memory;
2270         self
2271     }
offset(mut self, offset: DeviceSize) -> MappedMemoryRangeBuilder<'a>2272     pub fn offset(mut self, offset: DeviceSize) -> MappedMemoryRangeBuilder<'a> {
2273         self.inner.offset = offset;
2274         self
2275     }
size(mut self, size: DeviceSize) -> MappedMemoryRangeBuilder<'a>2276     pub fn size(mut self, size: DeviceSize) -> MappedMemoryRangeBuilder<'a> {
2277         self.inner.size = size;
2278         self
2279     }
2280     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2281     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2282     #[doc = r" valid extension structs can be pushed into the chain."]
2283     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2284     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMappedMemoryRange>( mut self, next: &'a mut T, ) -> MappedMemoryRangeBuilder<'a>2285     pub fn push_next<T: ExtendsMappedMemoryRange>(
2286         mut self,
2287         next: &'a mut T,
2288     ) -> MappedMemoryRangeBuilder<'a> {
2289         unsafe {
2290             let next_ptr = next as *mut T as *mut BaseOutStructure;
2291             let last_next = ptr_chain_iter(next).last().unwrap();
2292             (*last_next).p_next = self.inner.p_next as _;
2293             self.inner.p_next = next_ptr as _;
2294         }
2295         self
2296     }
2297     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2298     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2299     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MappedMemoryRange2300     pub fn build(self) -> MappedMemoryRange {
2301         self.inner
2302     }
2303 }
2304 #[repr(C)]
2305 #[derive(Copy, Clone, Default, Debug)]
2306 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatProperties.html>"]
2307 pub struct FormatProperties {
2308     pub linear_tiling_features: FormatFeatureFlags,
2309     pub optimal_tiling_features: FormatFeatureFlags,
2310     pub buffer_features: FormatFeatureFlags,
2311 }
2312 impl FormatProperties {
builder<'a>() -> FormatPropertiesBuilder<'a>2313     pub fn builder<'a>() -> FormatPropertiesBuilder<'a> {
2314         FormatPropertiesBuilder {
2315             inner: FormatProperties::default(),
2316             marker: ::std::marker::PhantomData,
2317         }
2318     }
2319 }
2320 #[repr(transparent)]
2321 pub struct FormatPropertiesBuilder<'a> {
2322     inner: FormatProperties,
2323     marker: ::std::marker::PhantomData<&'a ()>,
2324 }
2325 impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> {
2326     type Target = FormatProperties;
deref(&self) -> &Self::Target2327     fn deref(&self) -> &Self::Target {
2328         &self.inner
2329     }
2330 }
2331 impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2332     fn deref_mut(&mut self) -> &mut Self::Target {
2333         &mut self.inner
2334     }
2335 }
2336 impl<'a> FormatPropertiesBuilder<'a> {
linear_tiling_features( mut self, linear_tiling_features: FormatFeatureFlags, ) -> FormatPropertiesBuilder<'a>2337     pub fn linear_tiling_features(
2338         mut self,
2339         linear_tiling_features: FormatFeatureFlags,
2340     ) -> FormatPropertiesBuilder<'a> {
2341         self.inner.linear_tiling_features = linear_tiling_features;
2342         self
2343     }
optimal_tiling_features( mut self, optimal_tiling_features: FormatFeatureFlags, ) -> FormatPropertiesBuilder<'a>2344     pub fn optimal_tiling_features(
2345         mut self,
2346         optimal_tiling_features: FormatFeatureFlags,
2347     ) -> FormatPropertiesBuilder<'a> {
2348         self.inner.optimal_tiling_features = optimal_tiling_features;
2349         self
2350     }
buffer_features( mut self, buffer_features: FormatFeatureFlags, ) -> FormatPropertiesBuilder<'a>2351     pub fn buffer_features(
2352         mut self,
2353         buffer_features: FormatFeatureFlags,
2354     ) -> FormatPropertiesBuilder<'a> {
2355         self.inner.buffer_features = buffer_features;
2356         self
2357     }
2358     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2359     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2360     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FormatProperties2361     pub fn build(self) -> FormatProperties {
2362         self.inner
2363     }
2364 }
2365 #[repr(C)]
2366 #[derive(Copy, Clone, Default, Debug)]
2367 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatProperties.html>"]
2368 pub struct ImageFormatProperties {
2369     pub max_extent: Extent3D,
2370     pub max_mip_levels: u32,
2371     pub max_array_layers: u32,
2372     pub sample_counts: SampleCountFlags,
2373     pub max_resource_size: DeviceSize,
2374 }
2375 impl ImageFormatProperties {
builder<'a>() -> ImageFormatPropertiesBuilder<'a>2376     pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> {
2377         ImageFormatPropertiesBuilder {
2378             inner: ImageFormatProperties::default(),
2379             marker: ::std::marker::PhantomData,
2380         }
2381     }
2382 }
2383 #[repr(transparent)]
2384 pub struct ImageFormatPropertiesBuilder<'a> {
2385     inner: ImageFormatProperties,
2386     marker: ::std::marker::PhantomData<&'a ()>,
2387 }
2388 impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> {
2389     type Target = ImageFormatProperties;
deref(&self) -> &Self::Target2390     fn deref(&self) -> &Self::Target {
2391         &self.inner
2392     }
2393 }
2394 impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2395     fn deref_mut(&mut self) -> &mut Self::Target {
2396         &mut self.inner
2397     }
2398 }
2399 impl<'a> ImageFormatPropertiesBuilder<'a> {
max_extent(mut self, max_extent: Extent3D) -> ImageFormatPropertiesBuilder<'a>2400     pub fn max_extent(mut self, max_extent: Extent3D) -> ImageFormatPropertiesBuilder<'a> {
2401         self.inner.max_extent = max_extent;
2402         self
2403     }
max_mip_levels(mut self, max_mip_levels: u32) -> ImageFormatPropertiesBuilder<'a>2404     pub fn max_mip_levels(mut self, max_mip_levels: u32) -> ImageFormatPropertiesBuilder<'a> {
2405         self.inner.max_mip_levels = max_mip_levels;
2406         self
2407     }
max_array_layers(mut self, max_array_layers: u32) -> ImageFormatPropertiesBuilder<'a>2408     pub fn max_array_layers(mut self, max_array_layers: u32) -> ImageFormatPropertiesBuilder<'a> {
2409         self.inner.max_array_layers = max_array_layers;
2410         self
2411     }
sample_counts( mut self, sample_counts: SampleCountFlags, ) -> ImageFormatPropertiesBuilder<'a>2412     pub fn sample_counts(
2413         mut self,
2414         sample_counts: SampleCountFlags,
2415     ) -> ImageFormatPropertiesBuilder<'a> {
2416         self.inner.sample_counts = sample_counts;
2417         self
2418     }
max_resource_size( mut self, max_resource_size: DeviceSize, ) -> ImageFormatPropertiesBuilder<'a>2419     pub fn max_resource_size(
2420         mut self,
2421         max_resource_size: DeviceSize,
2422     ) -> ImageFormatPropertiesBuilder<'a> {
2423         self.inner.max_resource_size = max_resource_size;
2424         self
2425     }
2426     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2427     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2428     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageFormatProperties2429     pub fn build(self) -> ImageFormatProperties {
2430         self.inner
2431     }
2432 }
2433 #[repr(C)]
2434 #[derive(Copy, Clone, Default, Debug)]
2435 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBufferInfo.html>"]
2436 pub struct DescriptorBufferInfo {
2437     pub buffer: Buffer,
2438     pub offset: DeviceSize,
2439     pub range: DeviceSize,
2440 }
2441 impl DescriptorBufferInfo {
builder<'a>() -> DescriptorBufferInfoBuilder<'a>2442     pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> {
2443         DescriptorBufferInfoBuilder {
2444             inner: DescriptorBufferInfo::default(),
2445             marker: ::std::marker::PhantomData,
2446         }
2447     }
2448 }
2449 #[repr(transparent)]
2450 pub struct DescriptorBufferInfoBuilder<'a> {
2451     inner: DescriptorBufferInfo,
2452     marker: ::std::marker::PhantomData<&'a ()>,
2453 }
2454 impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> {
2455     type Target = DescriptorBufferInfo;
deref(&self) -> &Self::Target2456     fn deref(&self) -> &Self::Target {
2457         &self.inner
2458     }
2459 }
2460 impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2461     fn deref_mut(&mut self) -> &mut Self::Target {
2462         &mut self.inner
2463     }
2464 }
2465 impl<'a> DescriptorBufferInfoBuilder<'a> {
buffer(mut self, buffer: Buffer) -> DescriptorBufferInfoBuilder<'a>2466     pub fn buffer(mut self, buffer: Buffer) -> DescriptorBufferInfoBuilder<'a> {
2467         self.inner.buffer = buffer;
2468         self
2469     }
offset(mut self, offset: DeviceSize) -> DescriptorBufferInfoBuilder<'a>2470     pub fn offset(mut self, offset: DeviceSize) -> DescriptorBufferInfoBuilder<'a> {
2471         self.inner.offset = offset;
2472         self
2473     }
range(mut self, range: DeviceSize) -> DescriptorBufferInfoBuilder<'a>2474     pub fn range(mut self, range: DeviceSize) -> DescriptorBufferInfoBuilder<'a> {
2475         self.inner.range = range;
2476         self
2477     }
2478     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2479     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2480     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorBufferInfo2481     pub fn build(self) -> DescriptorBufferInfo {
2482         self.inner
2483     }
2484 }
2485 #[repr(C)]
2486 #[derive(Copy, Clone, Default, Debug)]
2487 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorImageInfo.html>"]
2488 pub struct DescriptorImageInfo {
2489     pub sampler: Sampler,
2490     pub image_view: ImageView,
2491     pub image_layout: ImageLayout,
2492 }
2493 impl DescriptorImageInfo {
builder<'a>() -> DescriptorImageInfoBuilder<'a>2494     pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> {
2495         DescriptorImageInfoBuilder {
2496             inner: DescriptorImageInfo::default(),
2497             marker: ::std::marker::PhantomData,
2498         }
2499     }
2500 }
2501 #[repr(transparent)]
2502 pub struct DescriptorImageInfoBuilder<'a> {
2503     inner: DescriptorImageInfo,
2504     marker: ::std::marker::PhantomData<&'a ()>,
2505 }
2506 impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> {
2507     type Target = DescriptorImageInfo;
deref(&self) -> &Self::Target2508     fn deref(&self) -> &Self::Target {
2509         &self.inner
2510     }
2511 }
2512 impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2513     fn deref_mut(&mut self) -> &mut Self::Target {
2514         &mut self.inner
2515     }
2516 }
2517 impl<'a> DescriptorImageInfoBuilder<'a> {
sampler(mut self, sampler: Sampler) -> DescriptorImageInfoBuilder<'a>2518     pub fn sampler(mut self, sampler: Sampler) -> DescriptorImageInfoBuilder<'a> {
2519         self.inner.sampler = sampler;
2520         self
2521     }
image_view(mut self, image_view: ImageView) -> DescriptorImageInfoBuilder<'a>2522     pub fn image_view(mut self, image_view: ImageView) -> DescriptorImageInfoBuilder<'a> {
2523         self.inner.image_view = image_view;
2524         self
2525     }
image_layout(mut self, image_layout: ImageLayout) -> DescriptorImageInfoBuilder<'a>2526     pub fn image_layout(mut self, image_layout: ImageLayout) -> DescriptorImageInfoBuilder<'a> {
2527         self.inner.image_layout = image_layout;
2528         self
2529     }
2530     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2531     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2532     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorImageInfo2533     pub fn build(self) -> DescriptorImageInfo {
2534         self.inner
2535     }
2536 }
2537 #[repr(C)]
2538 #[derive(Copy, Clone, Debug)]
2539 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSet.html>"]
2540 pub struct WriteDescriptorSet {
2541     pub s_type: StructureType,
2542     pub p_next: *const c_void,
2543     pub dst_set: DescriptorSet,
2544     pub dst_binding: u32,
2545     pub dst_array_element: u32,
2546     pub descriptor_count: u32,
2547     pub descriptor_type: DescriptorType,
2548     pub p_image_info: *const DescriptorImageInfo,
2549     pub p_buffer_info: *const DescriptorBufferInfo,
2550     pub p_texel_buffer_view: *const BufferView,
2551 }
2552 impl ::std::default::Default for WriteDescriptorSet {
default() -> WriteDescriptorSet2553     fn default() -> WriteDescriptorSet {
2554         WriteDescriptorSet {
2555             s_type: StructureType::WRITE_DESCRIPTOR_SET,
2556             p_next: ::std::ptr::null(),
2557             dst_set: DescriptorSet::default(),
2558             dst_binding: u32::default(),
2559             dst_array_element: u32::default(),
2560             descriptor_count: u32::default(),
2561             descriptor_type: DescriptorType::default(),
2562             p_image_info: ::std::ptr::null(),
2563             p_buffer_info: ::std::ptr::null(),
2564             p_texel_buffer_view: ::std::ptr::null(),
2565         }
2566     }
2567 }
2568 impl WriteDescriptorSet {
builder<'a>() -> WriteDescriptorSetBuilder<'a>2569     pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> {
2570         WriteDescriptorSetBuilder {
2571             inner: WriteDescriptorSet::default(),
2572             marker: ::std::marker::PhantomData,
2573         }
2574     }
2575 }
2576 #[repr(transparent)]
2577 pub struct WriteDescriptorSetBuilder<'a> {
2578     inner: WriteDescriptorSet,
2579     marker: ::std::marker::PhantomData<&'a ()>,
2580 }
2581 pub unsafe trait ExtendsWriteDescriptorSet {}
2582 impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> {
2583     type Target = WriteDescriptorSet;
deref(&self) -> &Self::Target2584     fn deref(&self) -> &Self::Target {
2585         &self.inner
2586     }
2587 }
2588 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2589     fn deref_mut(&mut self) -> &mut Self::Target {
2590         &mut self.inner
2591     }
2592 }
2593 impl<'a> WriteDescriptorSetBuilder<'a> {
dst_set(mut self, dst_set: DescriptorSet) -> WriteDescriptorSetBuilder<'a>2594     pub fn dst_set(mut self, dst_set: DescriptorSet) -> WriteDescriptorSetBuilder<'a> {
2595         self.inner.dst_set = dst_set;
2596         self
2597     }
dst_binding(mut self, dst_binding: u32) -> WriteDescriptorSetBuilder<'a>2598     pub fn dst_binding(mut self, dst_binding: u32) -> WriteDescriptorSetBuilder<'a> {
2599         self.inner.dst_binding = dst_binding;
2600         self
2601     }
dst_array_element(mut self, dst_array_element: u32) -> WriteDescriptorSetBuilder<'a>2602     pub fn dst_array_element(mut self, dst_array_element: u32) -> WriteDescriptorSetBuilder<'a> {
2603         self.inner.dst_array_element = dst_array_element;
2604         self
2605     }
descriptor_type( mut self, descriptor_type: DescriptorType, ) -> WriteDescriptorSetBuilder<'a>2606     pub fn descriptor_type(
2607         mut self,
2608         descriptor_type: DescriptorType,
2609     ) -> WriteDescriptorSetBuilder<'a> {
2610         self.inner.descriptor_type = descriptor_type;
2611         self
2612     }
image_info( mut self, image_info: &'a [DescriptorImageInfo], ) -> WriteDescriptorSetBuilder<'a>2613     pub fn image_info(
2614         mut self,
2615         image_info: &'a [DescriptorImageInfo],
2616     ) -> WriteDescriptorSetBuilder<'a> {
2617         self.inner.descriptor_count = image_info.len() as _;
2618         self.inner.p_image_info = image_info.as_ptr();
2619         self
2620     }
buffer_info( mut self, buffer_info: &'a [DescriptorBufferInfo], ) -> WriteDescriptorSetBuilder<'a>2621     pub fn buffer_info(
2622         mut self,
2623         buffer_info: &'a [DescriptorBufferInfo],
2624     ) -> WriteDescriptorSetBuilder<'a> {
2625         self.inner.descriptor_count = buffer_info.len() as _;
2626         self.inner.p_buffer_info = buffer_info.as_ptr();
2627         self
2628     }
texel_buffer_view( mut self, texel_buffer_view: &'a [BufferView], ) -> WriteDescriptorSetBuilder<'a>2629     pub fn texel_buffer_view(
2630         mut self,
2631         texel_buffer_view: &'a [BufferView],
2632     ) -> WriteDescriptorSetBuilder<'a> {
2633         self.inner.descriptor_count = texel_buffer_view.len() as _;
2634         self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr();
2635         self
2636     }
2637     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2638     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2639     #[doc = r" valid extension structs can be pushed into the chain."]
2640     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2641     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsWriteDescriptorSet>( mut self, next: &'a mut T, ) -> WriteDescriptorSetBuilder<'a>2642     pub fn push_next<T: ExtendsWriteDescriptorSet>(
2643         mut self,
2644         next: &'a mut T,
2645     ) -> WriteDescriptorSetBuilder<'a> {
2646         unsafe {
2647             let next_ptr = next as *mut T as *mut BaseOutStructure;
2648             let last_next = ptr_chain_iter(next).last().unwrap();
2649             (*last_next).p_next = self.inner.p_next as _;
2650             self.inner.p_next = next_ptr as _;
2651         }
2652         self
2653     }
2654     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2655     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2656     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSet2657     pub fn build(self) -> WriteDescriptorSet {
2658         self.inner
2659     }
2660 }
2661 #[repr(C)]
2662 #[derive(Copy, Clone, Debug)]
2663 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyDescriptorSet.html>"]
2664 pub struct CopyDescriptorSet {
2665     pub s_type: StructureType,
2666     pub p_next: *const c_void,
2667     pub src_set: DescriptorSet,
2668     pub src_binding: u32,
2669     pub src_array_element: u32,
2670     pub dst_set: DescriptorSet,
2671     pub dst_binding: u32,
2672     pub dst_array_element: u32,
2673     pub descriptor_count: u32,
2674 }
2675 impl ::std::default::Default for CopyDescriptorSet {
default() -> CopyDescriptorSet2676     fn default() -> CopyDescriptorSet {
2677         CopyDescriptorSet {
2678             s_type: StructureType::COPY_DESCRIPTOR_SET,
2679             p_next: ::std::ptr::null(),
2680             src_set: DescriptorSet::default(),
2681             src_binding: u32::default(),
2682             src_array_element: u32::default(),
2683             dst_set: DescriptorSet::default(),
2684             dst_binding: u32::default(),
2685             dst_array_element: u32::default(),
2686             descriptor_count: u32::default(),
2687         }
2688     }
2689 }
2690 impl CopyDescriptorSet {
builder<'a>() -> CopyDescriptorSetBuilder<'a>2691     pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> {
2692         CopyDescriptorSetBuilder {
2693             inner: CopyDescriptorSet::default(),
2694             marker: ::std::marker::PhantomData,
2695         }
2696     }
2697 }
2698 #[repr(transparent)]
2699 pub struct CopyDescriptorSetBuilder<'a> {
2700     inner: CopyDescriptorSet,
2701     marker: ::std::marker::PhantomData<&'a ()>,
2702 }
2703 pub unsafe trait ExtendsCopyDescriptorSet {}
2704 impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> {
2705     type Target = CopyDescriptorSet;
deref(&self) -> &Self::Target2706     fn deref(&self) -> &Self::Target {
2707         &self.inner
2708     }
2709 }
2710 impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2711     fn deref_mut(&mut self) -> &mut Self::Target {
2712         &mut self.inner
2713     }
2714 }
2715 impl<'a> CopyDescriptorSetBuilder<'a> {
src_set(mut self, src_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a>2716     pub fn src_set(mut self, src_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a> {
2717         self.inner.src_set = src_set;
2718         self
2719     }
src_binding(mut self, src_binding: u32) -> CopyDescriptorSetBuilder<'a>2720     pub fn src_binding(mut self, src_binding: u32) -> CopyDescriptorSetBuilder<'a> {
2721         self.inner.src_binding = src_binding;
2722         self
2723     }
src_array_element(mut self, src_array_element: u32) -> CopyDescriptorSetBuilder<'a>2724     pub fn src_array_element(mut self, src_array_element: u32) -> CopyDescriptorSetBuilder<'a> {
2725         self.inner.src_array_element = src_array_element;
2726         self
2727     }
dst_set(mut self, dst_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a>2728     pub fn dst_set(mut self, dst_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a> {
2729         self.inner.dst_set = dst_set;
2730         self
2731     }
dst_binding(mut self, dst_binding: u32) -> CopyDescriptorSetBuilder<'a>2732     pub fn dst_binding(mut self, dst_binding: u32) -> CopyDescriptorSetBuilder<'a> {
2733         self.inner.dst_binding = dst_binding;
2734         self
2735     }
dst_array_element(mut self, dst_array_element: u32) -> CopyDescriptorSetBuilder<'a>2736     pub fn dst_array_element(mut self, dst_array_element: u32) -> CopyDescriptorSetBuilder<'a> {
2737         self.inner.dst_array_element = dst_array_element;
2738         self
2739     }
descriptor_count(mut self, descriptor_count: u32) -> CopyDescriptorSetBuilder<'a>2740     pub fn descriptor_count(mut self, descriptor_count: u32) -> CopyDescriptorSetBuilder<'a> {
2741         self.inner.descriptor_count = descriptor_count;
2742         self
2743     }
2744     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2745     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2746     #[doc = r" valid extension structs can be pushed into the chain."]
2747     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2748     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyDescriptorSet>( mut self, next: &'a mut T, ) -> CopyDescriptorSetBuilder<'a>2749     pub fn push_next<T: ExtendsCopyDescriptorSet>(
2750         mut self,
2751         next: &'a mut T,
2752     ) -> CopyDescriptorSetBuilder<'a> {
2753         unsafe {
2754             let next_ptr = next as *mut T as *mut BaseOutStructure;
2755             let last_next = ptr_chain_iter(next).last().unwrap();
2756             (*last_next).p_next = self.inner.p_next as _;
2757             self.inner.p_next = next_ptr as _;
2758         }
2759         self
2760     }
2761     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2762     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2763     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyDescriptorSet2764     pub fn build(self) -> CopyDescriptorSet {
2765         self.inner
2766     }
2767 }
2768 #[repr(C)]
2769 #[derive(Copy, Clone, Debug)]
2770 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateInfo.html>"]
2771 pub struct BufferCreateInfo {
2772     pub s_type: StructureType,
2773     pub p_next: *const c_void,
2774     pub flags: BufferCreateFlags,
2775     pub size: DeviceSize,
2776     pub usage: BufferUsageFlags,
2777     pub sharing_mode: SharingMode,
2778     pub queue_family_index_count: u32,
2779     pub p_queue_family_indices: *const u32,
2780 }
2781 impl ::std::default::Default for BufferCreateInfo {
default() -> BufferCreateInfo2782     fn default() -> BufferCreateInfo {
2783         BufferCreateInfo {
2784             s_type: StructureType::BUFFER_CREATE_INFO,
2785             p_next: ::std::ptr::null(),
2786             flags: BufferCreateFlags::default(),
2787             size: DeviceSize::default(),
2788             usage: BufferUsageFlags::default(),
2789             sharing_mode: SharingMode::default(),
2790             queue_family_index_count: u32::default(),
2791             p_queue_family_indices: ::std::ptr::null(),
2792         }
2793     }
2794 }
2795 impl BufferCreateInfo {
builder<'a>() -> BufferCreateInfoBuilder<'a>2796     pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> {
2797         BufferCreateInfoBuilder {
2798             inner: BufferCreateInfo::default(),
2799             marker: ::std::marker::PhantomData,
2800         }
2801     }
2802 }
2803 #[repr(transparent)]
2804 pub struct BufferCreateInfoBuilder<'a> {
2805     inner: BufferCreateInfo,
2806     marker: ::std::marker::PhantomData<&'a ()>,
2807 }
2808 pub unsafe trait ExtendsBufferCreateInfo {}
2809 impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> {
2810     type Target = BufferCreateInfo;
deref(&self) -> &Self::Target2811     fn deref(&self) -> &Self::Target {
2812         &self.inner
2813     }
2814 }
2815 impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2816     fn deref_mut(&mut self) -> &mut Self::Target {
2817         &mut self.inner
2818     }
2819 }
2820 impl<'a> BufferCreateInfoBuilder<'a> {
flags(mut self, flags: BufferCreateFlags) -> BufferCreateInfoBuilder<'a>2821     pub fn flags(mut self, flags: BufferCreateFlags) -> BufferCreateInfoBuilder<'a> {
2822         self.inner.flags = flags;
2823         self
2824     }
size(mut self, size: DeviceSize) -> BufferCreateInfoBuilder<'a>2825     pub fn size(mut self, size: DeviceSize) -> BufferCreateInfoBuilder<'a> {
2826         self.inner.size = size;
2827         self
2828     }
usage(mut self, usage: BufferUsageFlags) -> BufferCreateInfoBuilder<'a>2829     pub fn usage(mut self, usage: BufferUsageFlags) -> BufferCreateInfoBuilder<'a> {
2830         self.inner.usage = usage;
2831         self
2832     }
sharing_mode(mut self, sharing_mode: SharingMode) -> BufferCreateInfoBuilder<'a>2833     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> BufferCreateInfoBuilder<'a> {
2834         self.inner.sharing_mode = sharing_mode;
2835         self
2836     }
queue_family_indices( mut self, queue_family_indices: &'a [u32], ) -> BufferCreateInfoBuilder<'a>2837     pub fn queue_family_indices(
2838         mut self,
2839         queue_family_indices: &'a [u32],
2840     ) -> BufferCreateInfoBuilder<'a> {
2841         self.inner.queue_family_index_count = queue_family_indices.len() as _;
2842         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
2843         self
2844     }
2845     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2846     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2847     #[doc = r" valid extension structs can be pushed into the chain."]
2848     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2849     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferCreateInfo>( mut self, next: &'a mut T, ) -> BufferCreateInfoBuilder<'a>2850     pub fn push_next<T: ExtendsBufferCreateInfo>(
2851         mut self,
2852         next: &'a mut T,
2853     ) -> BufferCreateInfoBuilder<'a> {
2854         unsafe {
2855             let next_ptr = next as *mut T as *mut BaseOutStructure;
2856             let last_next = ptr_chain_iter(next).last().unwrap();
2857             (*last_next).p_next = self.inner.p_next as _;
2858             self.inner.p_next = next_ptr as _;
2859         }
2860         self
2861     }
2862     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2863     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2864     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCreateInfo2865     pub fn build(self) -> BufferCreateInfo {
2866         self.inner
2867     }
2868 }
2869 #[repr(C)]
2870 #[derive(Copy, Clone, Debug)]
2871 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateInfo.html>"]
2872 pub struct BufferViewCreateInfo {
2873     pub s_type: StructureType,
2874     pub p_next: *const c_void,
2875     pub flags: BufferViewCreateFlags,
2876     pub buffer: Buffer,
2877     pub format: Format,
2878     pub offset: DeviceSize,
2879     pub range: DeviceSize,
2880 }
2881 impl ::std::default::Default for BufferViewCreateInfo {
default() -> BufferViewCreateInfo2882     fn default() -> BufferViewCreateInfo {
2883         BufferViewCreateInfo {
2884             s_type: StructureType::BUFFER_VIEW_CREATE_INFO,
2885             p_next: ::std::ptr::null(),
2886             flags: BufferViewCreateFlags::default(),
2887             buffer: Buffer::default(),
2888             format: Format::default(),
2889             offset: DeviceSize::default(),
2890             range: DeviceSize::default(),
2891         }
2892     }
2893 }
2894 impl BufferViewCreateInfo {
builder<'a>() -> BufferViewCreateInfoBuilder<'a>2895     pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> {
2896         BufferViewCreateInfoBuilder {
2897             inner: BufferViewCreateInfo::default(),
2898             marker: ::std::marker::PhantomData,
2899         }
2900     }
2901 }
2902 #[repr(transparent)]
2903 pub struct BufferViewCreateInfoBuilder<'a> {
2904     inner: BufferViewCreateInfo,
2905     marker: ::std::marker::PhantomData<&'a ()>,
2906 }
2907 pub unsafe trait ExtendsBufferViewCreateInfo {}
2908 impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> {
2909     type Target = BufferViewCreateInfo;
deref(&self) -> &Self::Target2910     fn deref(&self) -> &Self::Target {
2911         &self.inner
2912     }
2913 }
2914 impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2915     fn deref_mut(&mut self) -> &mut Self::Target {
2916         &mut self.inner
2917     }
2918 }
2919 impl<'a> BufferViewCreateInfoBuilder<'a> {
flags(mut self, flags: BufferViewCreateFlags) -> BufferViewCreateInfoBuilder<'a>2920     pub fn flags(mut self, flags: BufferViewCreateFlags) -> BufferViewCreateInfoBuilder<'a> {
2921         self.inner.flags = flags;
2922         self
2923     }
buffer(mut self, buffer: Buffer) -> BufferViewCreateInfoBuilder<'a>2924     pub fn buffer(mut self, buffer: Buffer) -> BufferViewCreateInfoBuilder<'a> {
2925         self.inner.buffer = buffer;
2926         self
2927     }
format(mut self, format: Format) -> BufferViewCreateInfoBuilder<'a>2928     pub fn format(mut self, format: Format) -> BufferViewCreateInfoBuilder<'a> {
2929         self.inner.format = format;
2930         self
2931     }
offset(mut self, offset: DeviceSize) -> BufferViewCreateInfoBuilder<'a>2932     pub fn offset(mut self, offset: DeviceSize) -> BufferViewCreateInfoBuilder<'a> {
2933         self.inner.offset = offset;
2934         self
2935     }
range(mut self, range: DeviceSize) -> BufferViewCreateInfoBuilder<'a>2936     pub fn range(mut self, range: DeviceSize) -> BufferViewCreateInfoBuilder<'a> {
2937         self.inner.range = range;
2938         self
2939     }
2940     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
2941     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
2942     #[doc = r" valid extension structs can be pushed into the chain."]
2943     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
2944     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferViewCreateInfo>( mut self, next: &'a mut T, ) -> BufferViewCreateInfoBuilder<'a>2945     pub fn push_next<T: ExtendsBufferViewCreateInfo>(
2946         mut self,
2947         next: &'a mut T,
2948     ) -> BufferViewCreateInfoBuilder<'a> {
2949         unsafe {
2950             let next_ptr = next as *mut T as *mut BaseOutStructure;
2951             let last_next = ptr_chain_iter(next).last().unwrap();
2952             (*last_next).p_next = self.inner.p_next as _;
2953             self.inner.p_next = next_ptr as _;
2954         }
2955         self
2956     }
2957     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
2958     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
2959     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferViewCreateInfo2960     pub fn build(self) -> BufferViewCreateInfo {
2961         self.inner
2962     }
2963 }
2964 #[repr(C)]
2965 #[derive(Copy, Clone, Default, Debug)]
2966 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresource.html>"]
2967 pub struct ImageSubresource {
2968     pub aspect_mask: ImageAspectFlags,
2969     pub mip_level: u32,
2970     pub array_layer: u32,
2971 }
2972 impl ImageSubresource {
builder<'a>() -> ImageSubresourceBuilder<'a>2973     pub fn builder<'a>() -> ImageSubresourceBuilder<'a> {
2974         ImageSubresourceBuilder {
2975             inner: ImageSubresource::default(),
2976             marker: ::std::marker::PhantomData,
2977         }
2978     }
2979 }
2980 #[repr(transparent)]
2981 pub struct ImageSubresourceBuilder<'a> {
2982     inner: ImageSubresource,
2983     marker: ::std::marker::PhantomData<&'a ()>,
2984 }
2985 impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> {
2986     type Target = ImageSubresource;
deref(&self) -> &Self::Target2987     fn deref(&self) -> &Self::Target {
2988         &self.inner
2989     }
2990 }
2991 impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target2992     fn deref_mut(&mut self) -> &mut Self::Target {
2993         &mut self.inner
2994     }
2995 }
2996 impl<'a> ImageSubresourceBuilder<'a> {
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ImageSubresourceBuilder<'a>2997     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ImageSubresourceBuilder<'a> {
2998         self.inner.aspect_mask = aspect_mask;
2999         self
3000     }
mip_level(mut self, mip_level: u32) -> ImageSubresourceBuilder<'a>3001     pub fn mip_level(mut self, mip_level: u32) -> ImageSubresourceBuilder<'a> {
3002         self.inner.mip_level = mip_level;
3003         self
3004     }
array_layer(mut self, array_layer: u32) -> ImageSubresourceBuilder<'a>3005     pub fn array_layer(mut self, array_layer: u32) -> ImageSubresourceBuilder<'a> {
3006         self.inner.array_layer = array_layer;
3007         self
3008     }
3009     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3010     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3011     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSubresource3012     pub fn build(self) -> ImageSubresource {
3013         self.inner
3014     }
3015 }
3016 #[repr(C)]
3017 #[derive(Copy, Clone, Default, Debug)]
3018 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresourceLayers.html>"]
3019 pub struct ImageSubresourceLayers {
3020     pub aspect_mask: ImageAspectFlags,
3021     pub mip_level: u32,
3022     pub base_array_layer: u32,
3023     pub layer_count: u32,
3024 }
3025 impl ImageSubresourceLayers {
builder<'a>() -> ImageSubresourceLayersBuilder<'a>3026     pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> {
3027         ImageSubresourceLayersBuilder {
3028             inner: ImageSubresourceLayers::default(),
3029             marker: ::std::marker::PhantomData,
3030         }
3031     }
3032 }
3033 #[repr(transparent)]
3034 pub struct ImageSubresourceLayersBuilder<'a> {
3035     inner: ImageSubresourceLayers,
3036     marker: ::std::marker::PhantomData<&'a ()>,
3037 }
3038 impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> {
3039     type Target = ImageSubresourceLayers;
deref(&self) -> &Self::Target3040     fn deref(&self) -> &Self::Target {
3041         &self.inner
3042     }
3043 }
3044 impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3045     fn deref_mut(&mut self) -> &mut Self::Target {
3046         &mut self.inner
3047     }
3048 }
3049 impl<'a> ImageSubresourceLayersBuilder<'a> {
aspect_mask( mut self, aspect_mask: ImageAspectFlags, ) -> ImageSubresourceLayersBuilder<'a>3050     pub fn aspect_mask(
3051         mut self,
3052         aspect_mask: ImageAspectFlags,
3053     ) -> ImageSubresourceLayersBuilder<'a> {
3054         self.inner.aspect_mask = aspect_mask;
3055         self
3056     }
mip_level(mut self, mip_level: u32) -> ImageSubresourceLayersBuilder<'a>3057     pub fn mip_level(mut self, mip_level: u32) -> ImageSubresourceLayersBuilder<'a> {
3058         self.inner.mip_level = mip_level;
3059         self
3060     }
base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceLayersBuilder<'a>3061     pub fn base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceLayersBuilder<'a> {
3062         self.inner.base_array_layer = base_array_layer;
3063         self
3064     }
layer_count(mut self, layer_count: u32) -> ImageSubresourceLayersBuilder<'a>3065     pub fn layer_count(mut self, layer_count: u32) -> ImageSubresourceLayersBuilder<'a> {
3066         self.inner.layer_count = layer_count;
3067         self
3068     }
3069     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3070     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3071     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSubresourceLayers3072     pub fn build(self) -> ImageSubresourceLayers {
3073         self.inner
3074     }
3075 }
3076 #[repr(C)]
3077 #[derive(Copy, Clone, Default, Debug)]
3078 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresourceRange.html>"]
3079 pub struct ImageSubresourceRange {
3080     pub aspect_mask: ImageAspectFlags,
3081     pub base_mip_level: u32,
3082     pub level_count: u32,
3083     pub base_array_layer: u32,
3084     pub layer_count: u32,
3085 }
3086 impl ImageSubresourceRange {
builder<'a>() -> ImageSubresourceRangeBuilder<'a>3087     pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> {
3088         ImageSubresourceRangeBuilder {
3089             inner: ImageSubresourceRange::default(),
3090             marker: ::std::marker::PhantomData,
3091         }
3092     }
3093 }
3094 #[repr(transparent)]
3095 pub struct ImageSubresourceRangeBuilder<'a> {
3096     inner: ImageSubresourceRange,
3097     marker: ::std::marker::PhantomData<&'a ()>,
3098 }
3099 impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> {
3100     type Target = ImageSubresourceRange;
deref(&self) -> &Self::Target3101     fn deref(&self) -> &Self::Target {
3102         &self.inner
3103     }
3104 }
3105 impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3106     fn deref_mut(&mut self) -> &mut Self::Target {
3107         &mut self.inner
3108     }
3109 }
3110 impl<'a> ImageSubresourceRangeBuilder<'a> {
aspect_mask( mut self, aspect_mask: ImageAspectFlags, ) -> ImageSubresourceRangeBuilder<'a>3111     pub fn aspect_mask(
3112         mut self,
3113         aspect_mask: ImageAspectFlags,
3114     ) -> ImageSubresourceRangeBuilder<'a> {
3115         self.inner.aspect_mask = aspect_mask;
3116         self
3117     }
base_mip_level(mut self, base_mip_level: u32) -> ImageSubresourceRangeBuilder<'a>3118     pub fn base_mip_level(mut self, base_mip_level: u32) -> ImageSubresourceRangeBuilder<'a> {
3119         self.inner.base_mip_level = base_mip_level;
3120         self
3121     }
level_count(mut self, level_count: u32) -> ImageSubresourceRangeBuilder<'a>3122     pub fn level_count(mut self, level_count: u32) -> ImageSubresourceRangeBuilder<'a> {
3123         self.inner.level_count = level_count;
3124         self
3125     }
base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceRangeBuilder<'a>3126     pub fn base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceRangeBuilder<'a> {
3127         self.inner.base_array_layer = base_array_layer;
3128         self
3129     }
layer_count(mut self, layer_count: u32) -> ImageSubresourceRangeBuilder<'a>3130     pub fn layer_count(mut self, layer_count: u32) -> ImageSubresourceRangeBuilder<'a> {
3131         self.inner.layer_count = layer_count;
3132         self
3133     }
3134     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3135     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3136     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSubresourceRange3137     pub fn build(self) -> ImageSubresourceRange {
3138         self.inner
3139     }
3140 }
3141 #[repr(C)]
3142 #[derive(Copy, Clone, Debug)]
3143 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryBarrier.html>"]
3144 pub struct MemoryBarrier {
3145     pub s_type: StructureType,
3146     pub p_next: *const c_void,
3147     pub src_access_mask: AccessFlags,
3148     pub dst_access_mask: AccessFlags,
3149 }
3150 impl ::std::default::Default for MemoryBarrier {
default() -> MemoryBarrier3151     fn default() -> MemoryBarrier {
3152         MemoryBarrier {
3153             s_type: StructureType::MEMORY_BARRIER,
3154             p_next: ::std::ptr::null(),
3155             src_access_mask: AccessFlags::default(),
3156             dst_access_mask: AccessFlags::default(),
3157         }
3158     }
3159 }
3160 impl MemoryBarrier {
builder<'a>() -> MemoryBarrierBuilder<'a>3161     pub fn builder<'a>() -> MemoryBarrierBuilder<'a> {
3162         MemoryBarrierBuilder {
3163             inner: MemoryBarrier::default(),
3164             marker: ::std::marker::PhantomData,
3165         }
3166     }
3167 }
3168 #[repr(transparent)]
3169 pub struct MemoryBarrierBuilder<'a> {
3170     inner: MemoryBarrier,
3171     marker: ::std::marker::PhantomData<&'a ()>,
3172 }
3173 pub unsafe trait ExtendsMemoryBarrier {}
3174 impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> {
3175     type Target = MemoryBarrier;
deref(&self) -> &Self::Target3176     fn deref(&self) -> &Self::Target {
3177         &self.inner
3178     }
3179 }
3180 impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3181     fn deref_mut(&mut self) -> &mut Self::Target {
3182         &mut self.inner
3183     }
3184 }
3185 impl<'a> MemoryBarrierBuilder<'a> {
src_access_mask(mut self, src_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a>3186     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a> {
3187         self.inner.src_access_mask = src_access_mask;
3188         self
3189     }
dst_access_mask(mut self, dst_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a>3190     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a> {
3191         self.inner.dst_access_mask = dst_access_mask;
3192         self
3193     }
3194     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3195     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3196     #[doc = r" valid extension structs can be pushed into the chain."]
3197     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3198     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryBarrier>( mut self, next: &'a mut T, ) -> MemoryBarrierBuilder<'a>3199     pub fn push_next<T: ExtendsMemoryBarrier>(
3200         mut self,
3201         next: &'a mut T,
3202     ) -> MemoryBarrierBuilder<'a> {
3203         unsafe {
3204             let next_ptr = next as *mut T as *mut BaseOutStructure;
3205             let last_next = ptr_chain_iter(next).last().unwrap();
3206             (*last_next).p_next = self.inner.p_next as _;
3207             self.inner.p_next = next_ptr as _;
3208         }
3209         self
3210     }
3211     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3212     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3213     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryBarrier3214     pub fn build(self) -> MemoryBarrier {
3215         self.inner
3216     }
3217 }
3218 #[repr(C)]
3219 #[derive(Copy, Clone, Debug)]
3220 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferMemoryBarrier.html>"]
3221 pub struct BufferMemoryBarrier {
3222     pub s_type: StructureType,
3223     pub p_next: *const c_void,
3224     pub src_access_mask: AccessFlags,
3225     pub dst_access_mask: AccessFlags,
3226     pub src_queue_family_index: u32,
3227     pub dst_queue_family_index: u32,
3228     pub buffer: Buffer,
3229     pub offset: DeviceSize,
3230     pub size: DeviceSize,
3231 }
3232 impl ::std::default::Default for BufferMemoryBarrier {
default() -> BufferMemoryBarrier3233     fn default() -> BufferMemoryBarrier {
3234         BufferMemoryBarrier {
3235             s_type: StructureType::BUFFER_MEMORY_BARRIER,
3236             p_next: ::std::ptr::null(),
3237             src_access_mask: AccessFlags::default(),
3238             dst_access_mask: AccessFlags::default(),
3239             src_queue_family_index: u32::default(),
3240             dst_queue_family_index: u32::default(),
3241             buffer: Buffer::default(),
3242             offset: DeviceSize::default(),
3243             size: DeviceSize::default(),
3244         }
3245     }
3246 }
3247 impl BufferMemoryBarrier {
builder<'a>() -> BufferMemoryBarrierBuilder<'a>3248     pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> {
3249         BufferMemoryBarrierBuilder {
3250             inner: BufferMemoryBarrier::default(),
3251             marker: ::std::marker::PhantomData,
3252         }
3253     }
3254 }
3255 #[repr(transparent)]
3256 pub struct BufferMemoryBarrierBuilder<'a> {
3257     inner: BufferMemoryBarrier,
3258     marker: ::std::marker::PhantomData<&'a ()>,
3259 }
3260 pub unsafe trait ExtendsBufferMemoryBarrier {}
3261 impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> {
3262     type Target = BufferMemoryBarrier;
deref(&self) -> &Self::Target3263     fn deref(&self) -> &Self::Target {
3264         &self.inner
3265     }
3266 }
3267 impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3268     fn deref_mut(&mut self) -> &mut Self::Target {
3269         &mut self.inner
3270     }
3271 }
3272 impl<'a> BufferMemoryBarrierBuilder<'a> {
src_access_mask( mut self, src_access_mask: AccessFlags, ) -> BufferMemoryBarrierBuilder<'a>3273     pub fn src_access_mask(
3274         mut self,
3275         src_access_mask: AccessFlags,
3276     ) -> BufferMemoryBarrierBuilder<'a> {
3277         self.inner.src_access_mask = src_access_mask;
3278         self
3279     }
dst_access_mask( mut self, dst_access_mask: AccessFlags, ) -> BufferMemoryBarrierBuilder<'a>3280     pub fn dst_access_mask(
3281         mut self,
3282         dst_access_mask: AccessFlags,
3283     ) -> BufferMemoryBarrierBuilder<'a> {
3284         self.inner.dst_access_mask = dst_access_mask;
3285         self
3286     }
src_queue_family_index( mut self, src_queue_family_index: u32, ) -> BufferMemoryBarrierBuilder<'a>3287     pub fn src_queue_family_index(
3288         mut self,
3289         src_queue_family_index: u32,
3290     ) -> BufferMemoryBarrierBuilder<'a> {
3291         self.inner.src_queue_family_index = src_queue_family_index;
3292         self
3293     }
dst_queue_family_index( mut self, dst_queue_family_index: u32, ) -> BufferMemoryBarrierBuilder<'a>3294     pub fn dst_queue_family_index(
3295         mut self,
3296         dst_queue_family_index: u32,
3297     ) -> BufferMemoryBarrierBuilder<'a> {
3298         self.inner.dst_queue_family_index = dst_queue_family_index;
3299         self
3300     }
buffer(mut self, buffer: Buffer) -> BufferMemoryBarrierBuilder<'a>3301     pub fn buffer(mut self, buffer: Buffer) -> BufferMemoryBarrierBuilder<'a> {
3302         self.inner.buffer = buffer;
3303         self
3304     }
offset(mut self, offset: DeviceSize) -> BufferMemoryBarrierBuilder<'a>3305     pub fn offset(mut self, offset: DeviceSize) -> BufferMemoryBarrierBuilder<'a> {
3306         self.inner.offset = offset;
3307         self
3308     }
size(mut self, size: DeviceSize) -> BufferMemoryBarrierBuilder<'a>3309     pub fn size(mut self, size: DeviceSize) -> BufferMemoryBarrierBuilder<'a> {
3310         self.inner.size = size;
3311         self
3312     }
3313     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3314     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3315     #[doc = r" valid extension structs can be pushed into the chain."]
3316     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3317     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferMemoryBarrier>( mut self, next: &'a mut T, ) -> BufferMemoryBarrierBuilder<'a>3318     pub fn push_next<T: ExtendsBufferMemoryBarrier>(
3319         mut self,
3320         next: &'a mut T,
3321     ) -> BufferMemoryBarrierBuilder<'a> {
3322         unsafe {
3323             let next_ptr = next as *mut T as *mut BaseOutStructure;
3324             let last_next = ptr_chain_iter(next).last().unwrap();
3325             (*last_next).p_next = self.inner.p_next as _;
3326             self.inner.p_next = next_ptr as _;
3327         }
3328         self
3329     }
3330     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3331     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3332     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferMemoryBarrier3333     pub fn build(self) -> BufferMemoryBarrier {
3334         self.inner
3335     }
3336 }
3337 #[repr(C)]
3338 #[derive(Copy, Clone, Debug)]
3339 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageMemoryBarrier.html>"]
3340 pub struct ImageMemoryBarrier {
3341     pub s_type: StructureType,
3342     pub p_next: *const c_void,
3343     pub src_access_mask: AccessFlags,
3344     pub dst_access_mask: AccessFlags,
3345     pub old_layout: ImageLayout,
3346     pub new_layout: ImageLayout,
3347     pub src_queue_family_index: u32,
3348     pub dst_queue_family_index: u32,
3349     pub image: Image,
3350     pub subresource_range: ImageSubresourceRange,
3351 }
3352 impl ::std::default::Default for ImageMemoryBarrier {
default() -> ImageMemoryBarrier3353     fn default() -> ImageMemoryBarrier {
3354         ImageMemoryBarrier {
3355             s_type: StructureType::IMAGE_MEMORY_BARRIER,
3356             p_next: ::std::ptr::null(),
3357             src_access_mask: AccessFlags::default(),
3358             dst_access_mask: AccessFlags::default(),
3359             old_layout: ImageLayout::default(),
3360             new_layout: ImageLayout::default(),
3361             src_queue_family_index: u32::default(),
3362             dst_queue_family_index: u32::default(),
3363             image: Image::default(),
3364             subresource_range: ImageSubresourceRange::default(),
3365         }
3366     }
3367 }
3368 impl ImageMemoryBarrier {
builder<'a>() -> ImageMemoryBarrierBuilder<'a>3369     pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> {
3370         ImageMemoryBarrierBuilder {
3371             inner: ImageMemoryBarrier::default(),
3372             marker: ::std::marker::PhantomData,
3373         }
3374     }
3375 }
3376 #[repr(transparent)]
3377 pub struct ImageMemoryBarrierBuilder<'a> {
3378     inner: ImageMemoryBarrier,
3379     marker: ::std::marker::PhantomData<&'a ()>,
3380 }
3381 pub unsafe trait ExtendsImageMemoryBarrier {}
3382 impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> {
3383     type Target = ImageMemoryBarrier;
deref(&self) -> &Self::Target3384     fn deref(&self) -> &Self::Target {
3385         &self.inner
3386     }
3387 }
3388 impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3389     fn deref_mut(&mut self) -> &mut Self::Target {
3390         &mut self.inner
3391     }
3392 }
3393 impl<'a> ImageMemoryBarrierBuilder<'a> {
src_access_mask( mut self, src_access_mask: AccessFlags, ) -> ImageMemoryBarrierBuilder<'a>3394     pub fn src_access_mask(
3395         mut self,
3396         src_access_mask: AccessFlags,
3397     ) -> ImageMemoryBarrierBuilder<'a> {
3398         self.inner.src_access_mask = src_access_mask;
3399         self
3400     }
dst_access_mask( mut self, dst_access_mask: AccessFlags, ) -> ImageMemoryBarrierBuilder<'a>3401     pub fn dst_access_mask(
3402         mut self,
3403         dst_access_mask: AccessFlags,
3404     ) -> ImageMemoryBarrierBuilder<'a> {
3405         self.inner.dst_access_mask = dst_access_mask;
3406         self
3407     }
old_layout(mut self, old_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a>3408     pub fn old_layout(mut self, old_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a> {
3409         self.inner.old_layout = old_layout;
3410         self
3411     }
new_layout(mut self, new_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a>3412     pub fn new_layout(mut self, new_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a> {
3413         self.inner.new_layout = new_layout;
3414         self
3415     }
src_queue_family_index( mut self, src_queue_family_index: u32, ) -> ImageMemoryBarrierBuilder<'a>3416     pub fn src_queue_family_index(
3417         mut self,
3418         src_queue_family_index: u32,
3419     ) -> ImageMemoryBarrierBuilder<'a> {
3420         self.inner.src_queue_family_index = src_queue_family_index;
3421         self
3422     }
dst_queue_family_index( mut self, dst_queue_family_index: u32, ) -> ImageMemoryBarrierBuilder<'a>3423     pub fn dst_queue_family_index(
3424         mut self,
3425         dst_queue_family_index: u32,
3426     ) -> ImageMemoryBarrierBuilder<'a> {
3427         self.inner.dst_queue_family_index = dst_queue_family_index;
3428         self
3429     }
image(mut self, image: Image) -> ImageMemoryBarrierBuilder<'a>3430     pub fn image(mut self, image: Image) -> ImageMemoryBarrierBuilder<'a> {
3431         self.inner.image = image;
3432         self
3433     }
subresource_range( mut self, subresource_range: ImageSubresourceRange, ) -> ImageMemoryBarrierBuilder<'a>3434     pub fn subresource_range(
3435         mut self,
3436         subresource_range: ImageSubresourceRange,
3437     ) -> ImageMemoryBarrierBuilder<'a> {
3438         self.inner.subresource_range = subresource_range;
3439         self
3440     }
3441     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3442     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3443     #[doc = r" valid extension structs can be pushed into the chain."]
3444     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3445     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageMemoryBarrier>( mut self, next: &'a mut T, ) -> ImageMemoryBarrierBuilder<'a>3446     pub fn push_next<T: ExtendsImageMemoryBarrier>(
3447         mut self,
3448         next: &'a mut T,
3449     ) -> ImageMemoryBarrierBuilder<'a> {
3450         unsafe {
3451             let next_ptr = next as *mut T as *mut BaseOutStructure;
3452             let last_next = ptr_chain_iter(next).last().unwrap();
3453             (*last_next).p_next = self.inner.p_next as _;
3454             self.inner.p_next = next_ptr as _;
3455         }
3456         self
3457     }
3458     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3459     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3460     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageMemoryBarrier3461     pub fn build(self) -> ImageMemoryBarrier {
3462         self.inner
3463     }
3464 }
3465 #[repr(C)]
3466 #[derive(Copy, Clone, Debug)]
3467 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateInfo.html>"]
3468 pub struct ImageCreateInfo {
3469     pub s_type: StructureType,
3470     pub p_next: *const c_void,
3471     pub flags: ImageCreateFlags,
3472     pub image_type: ImageType,
3473     pub format: Format,
3474     pub extent: Extent3D,
3475     pub mip_levels: u32,
3476     pub array_layers: u32,
3477     pub samples: SampleCountFlags,
3478     pub tiling: ImageTiling,
3479     pub usage: ImageUsageFlags,
3480     pub sharing_mode: SharingMode,
3481     pub queue_family_index_count: u32,
3482     pub p_queue_family_indices: *const u32,
3483     pub initial_layout: ImageLayout,
3484 }
3485 impl ::std::default::Default for ImageCreateInfo {
default() -> ImageCreateInfo3486     fn default() -> ImageCreateInfo {
3487         ImageCreateInfo {
3488             s_type: StructureType::IMAGE_CREATE_INFO,
3489             p_next: ::std::ptr::null(),
3490             flags: ImageCreateFlags::default(),
3491             image_type: ImageType::default(),
3492             format: Format::default(),
3493             extent: Extent3D::default(),
3494             mip_levels: u32::default(),
3495             array_layers: u32::default(),
3496             samples: SampleCountFlags::default(),
3497             tiling: ImageTiling::default(),
3498             usage: ImageUsageFlags::default(),
3499             sharing_mode: SharingMode::default(),
3500             queue_family_index_count: u32::default(),
3501             p_queue_family_indices: ::std::ptr::null(),
3502             initial_layout: ImageLayout::default(),
3503         }
3504     }
3505 }
3506 impl ImageCreateInfo {
builder<'a>() -> ImageCreateInfoBuilder<'a>3507     pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> {
3508         ImageCreateInfoBuilder {
3509             inner: ImageCreateInfo::default(),
3510             marker: ::std::marker::PhantomData,
3511         }
3512     }
3513 }
3514 #[repr(transparent)]
3515 pub struct ImageCreateInfoBuilder<'a> {
3516     inner: ImageCreateInfo,
3517     marker: ::std::marker::PhantomData<&'a ()>,
3518 }
3519 pub unsafe trait ExtendsImageCreateInfo {}
3520 impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> {
3521     type Target = ImageCreateInfo;
deref(&self) -> &Self::Target3522     fn deref(&self) -> &Self::Target {
3523         &self.inner
3524     }
3525 }
3526 impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3527     fn deref_mut(&mut self) -> &mut Self::Target {
3528         &mut self.inner
3529     }
3530 }
3531 impl<'a> ImageCreateInfoBuilder<'a> {
flags(mut self, flags: ImageCreateFlags) -> ImageCreateInfoBuilder<'a>3532     pub fn flags(mut self, flags: ImageCreateFlags) -> ImageCreateInfoBuilder<'a> {
3533         self.inner.flags = flags;
3534         self
3535     }
image_type(mut self, image_type: ImageType) -> ImageCreateInfoBuilder<'a>3536     pub fn image_type(mut self, image_type: ImageType) -> ImageCreateInfoBuilder<'a> {
3537         self.inner.image_type = image_type;
3538         self
3539     }
format(mut self, format: Format) -> ImageCreateInfoBuilder<'a>3540     pub fn format(mut self, format: Format) -> ImageCreateInfoBuilder<'a> {
3541         self.inner.format = format;
3542         self
3543     }
extent(mut self, extent: Extent3D) -> ImageCreateInfoBuilder<'a>3544     pub fn extent(mut self, extent: Extent3D) -> ImageCreateInfoBuilder<'a> {
3545         self.inner.extent = extent;
3546         self
3547     }
mip_levels(mut self, mip_levels: u32) -> ImageCreateInfoBuilder<'a>3548     pub fn mip_levels(mut self, mip_levels: u32) -> ImageCreateInfoBuilder<'a> {
3549         self.inner.mip_levels = mip_levels;
3550         self
3551     }
array_layers(mut self, array_layers: u32) -> ImageCreateInfoBuilder<'a>3552     pub fn array_layers(mut self, array_layers: u32) -> ImageCreateInfoBuilder<'a> {
3553         self.inner.array_layers = array_layers;
3554         self
3555     }
samples(mut self, samples: SampleCountFlags) -> ImageCreateInfoBuilder<'a>3556     pub fn samples(mut self, samples: SampleCountFlags) -> ImageCreateInfoBuilder<'a> {
3557         self.inner.samples = samples;
3558         self
3559     }
tiling(mut self, tiling: ImageTiling) -> ImageCreateInfoBuilder<'a>3560     pub fn tiling(mut self, tiling: ImageTiling) -> ImageCreateInfoBuilder<'a> {
3561         self.inner.tiling = tiling;
3562         self
3563     }
usage(mut self, usage: ImageUsageFlags) -> ImageCreateInfoBuilder<'a>3564     pub fn usage(mut self, usage: ImageUsageFlags) -> ImageCreateInfoBuilder<'a> {
3565         self.inner.usage = usage;
3566         self
3567     }
sharing_mode(mut self, sharing_mode: SharingMode) -> ImageCreateInfoBuilder<'a>3568     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> ImageCreateInfoBuilder<'a> {
3569         self.inner.sharing_mode = sharing_mode;
3570         self
3571     }
queue_family_indices( mut self, queue_family_indices: &'a [u32], ) -> ImageCreateInfoBuilder<'a>3572     pub fn queue_family_indices(
3573         mut self,
3574         queue_family_indices: &'a [u32],
3575     ) -> ImageCreateInfoBuilder<'a> {
3576         self.inner.queue_family_index_count = queue_family_indices.len() as _;
3577         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
3578         self
3579     }
initial_layout(mut self, initial_layout: ImageLayout) -> ImageCreateInfoBuilder<'a>3580     pub fn initial_layout(mut self, initial_layout: ImageLayout) -> ImageCreateInfoBuilder<'a> {
3581         self.inner.initial_layout = initial_layout;
3582         self
3583     }
3584     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3585     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3586     #[doc = r" valid extension structs can be pushed into the chain."]
3587     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3588     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageCreateInfo>( mut self, next: &'a mut T, ) -> ImageCreateInfoBuilder<'a>3589     pub fn push_next<T: ExtendsImageCreateInfo>(
3590         mut self,
3591         next: &'a mut T,
3592     ) -> ImageCreateInfoBuilder<'a> {
3593         unsafe {
3594             let next_ptr = next as *mut T as *mut BaseOutStructure;
3595             let last_next = ptr_chain_iter(next).last().unwrap();
3596             (*last_next).p_next = self.inner.p_next as _;
3597             self.inner.p_next = next_ptr as _;
3598         }
3599         self
3600     }
3601     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3602     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3603     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCreateInfo3604     pub fn build(self) -> ImageCreateInfo {
3605         self.inner
3606     }
3607 }
3608 #[repr(C)]
3609 #[derive(Copy, Clone, Default, Debug)]
3610 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubresourceLayout.html>"]
3611 pub struct SubresourceLayout {
3612     pub offset: DeviceSize,
3613     pub size: DeviceSize,
3614     pub row_pitch: DeviceSize,
3615     pub array_pitch: DeviceSize,
3616     pub depth_pitch: DeviceSize,
3617 }
3618 impl SubresourceLayout {
builder<'a>() -> SubresourceLayoutBuilder<'a>3619     pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> {
3620         SubresourceLayoutBuilder {
3621             inner: SubresourceLayout::default(),
3622             marker: ::std::marker::PhantomData,
3623         }
3624     }
3625 }
3626 #[repr(transparent)]
3627 pub struct SubresourceLayoutBuilder<'a> {
3628     inner: SubresourceLayout,
3629     marker: ::std::marker::PhantomData<&'a ()>,
3630 }
3631 impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> {
3632     type Target = SubresourceLayout;
deref(&self) -> &Self::Target3633     fn deref(&self) -> &Self::Target {
3634         &self.inner
3635     }
3636 }
3637 impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3638     fn deref_mut(&mut self) -> &mut Self::Target {
3639         &mut self.inner
3640     }
3641 }
3642 impl<'a> SubresourceLayoutBuilder<'a> {
offset(mut self, offset: DeviceSize) -> SubresourceLayoutBuilder<'a>3643     pub fn offset(mut self, offset: DeviceSize) -> SubresourceLayoutBuilder<'a> {
3644         self.inner.offset = offset;
3645         self
3646     }
size(mut self, size: DeviceSize) -> SubresourceLayoutBuilder<'a>3647     pub fn size(mut self, size: DeviceSize) -> SubresourceLayoutBuilder<'a> {
3648         self.inner.size = size;
3649         self
3650     }
row_pitch(mut self, row_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a>3651     pub fn row_pitch(mut self, row_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> {
3652         self.inner.row_pitch = row_pitch;
3653         self
3654     }
array_pitch(mut self, array_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a>3655     pub fn array_pitch(mut self, array_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> {
3656         self.inner.array_pitch = array_pitch;
3657         self
3658     }
depth_pitch(mut self, depth_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a>3659     pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> {
3660         self.inner.depth_pitch = depth_pitch;
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."]
build(self) -> SubresourceLayout3666     pub fn build(self) -> SubresourceLayout {
3667         self.inner
3668     }
3669 }
3670 #[repr(C)]
3671 #[derive(Copy, Clone, Debug)]
3672 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateInfo.html>"]
3673 pub struct ImageViewCreateInfo {
3674     pub s_type: StructureType,
3675     pub p_next: *const c_void,
3676     pub flags: ImageViewCreateFlags,
3677     pub image: Image,
3678     pub view_type: ImageViewType,
3679     pub format: Format,
3680     pub components: ComponentMapping,
3681     pub subresource_range: ImageSubresourceRange,
3682 }
3683 impl ::std::default::Default for ImageViewCreateInfo {
default() -> ImageViewCreateInfo3684     fn default() -> ImageViewCreateInfo {
3685         ImageViewCreateInfo {
3686             s_type: StructureType::IMAGE_VIEW_CREATE_INFO,
3687             p_next: ::std::ptr::null(),
3688             flags: ImageViewCreateFlags::default(),
3689             image: Image::default(),
3690             view_type: ImageViewType::default(),
3691             format: Format::default(),
3692             components: ComponentMapping::default(),
3693             subresource_range: ImageSubresourceRange::default(),
3694         }
3695     }
3696 }
3697 impl ImageViewCreateInfo {
builder<'a>() -> ImageViewCreateInfoBuilder<'a>3698     pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> {
3699         ImageViewCreateInfoBuilder {
3700             inner: ImageViewCreateInfo::default(),
3701             marker: ::std::marker::PhantomData,
3702         }
3703     }
3704 }
3705 #[repr(transparent)]
3706 pub struct ImageViewCreateInfoBuilder<'a> {
3707     inner: ImageViewCreateInfo,
3708     marker: ::std::marker::PhantomData<&'a ()>,
3709 }
3710 pub unsafe trait ExtendsImageViewCreateInfo {}
3711 impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> {
3712     type Target = ImageViewCreateInfo;
deref(&self) -> &Self::Target3713     fn deref(&self) -> &Self::Target {
3714         &self.inner
3715     }
3716 }
3717 impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3718     fn deref_mut(&mut self) -> &mut Self::Target {
3719         &mut self.inner
3720     }
3721 }
3722 impl<'a> ImageViewCreateInfoBuilder<'a> {
flags(mut self, flags: ImageViewCreateFlags) -> ImageViewCreateInfoBuilder<'a>3723     pub fn flags(mut self, flags: ImageViewCreateFlags) -> ImageViewCreateInfoBuilder<'a> {
3724         self.inner.flags = flags;
3725         self
3726     }
image(mut self, image: Image) -> ImageViewCreateInfoBuilder<'a>3727     pub fn image(mut self, image: Image) -> ImageViewCreateInfoBuilder<'a> {
3728         self.inner.image = image;
3729         self
3730     }
view_type(mut self, view_type: ImageViewType) -> ImageViewCreateInfoBuilder<'a>3731     pub fn view_type(mut self, view_type: ImageViewType) -> ImageViewCreateInfoBuilder<'a> {
3732         self.inner.view_type = view_type;
3733         self
3734     }
format(mut self, format: Format) -> ImageViewCreateInfoBuilder<'a>3735     pub fn format(mut self, format: Format) -> ImageViewCreateInfoBuilder<'a> {
3736         self.inner.format = format;
3737         self
3738     }
components(mut self, components: ComponentMapping) -> ImageViewCreateInfoBuilder<'a>3739     pub fn components(mut self, components: ComponentMapping) -> ImageViewCreateInfoBuilder<'a> {
3740         self.inner.components = components;
3741         self
3742     }
subresource_range( mut self, subresource_range: ImageSubresourceRange, ) -> ImageViewCreateInfoBuilder<'a>3743     pub fn subresource_range(
3744         mut self,
3745         subresource_range: ImageSubresourceRange,
3746     ) -> ImageViewCreateInfoBuilder<'a> {
3747         self.inner.subresource_range = subresource_range;
3748         self
3749     }
3750     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
3751     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
3752     #[doc = r" valid extension structs can be pushed into the chain."]
3753     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
3754     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageViewCreateInfo>( mut self, next: &'a mut T, ) -> ImageViewCreateInfoBuilder<'a>3755     pub fn push_next<T: ExtendsImageViewCreateInfo>(
3756         mut self,
3757         next: &'a mut T,
3758     ) -> ImageViewCreateInfoBuilder<'a> {
3759         unsafe {
3760             let next_ptr = next as *mut T as *mut BaseOutStructure;
3761             let last_next = ptr_chain_iter(next).last().unwrap();
3762             (*last_next).p_next = self.inner.p_next as _;
3763             self.inner.p_next = next_ptr as _;
3764         }
3765         self
3766     }
3767     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3768     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3769     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewCreateInfo3770     pub fn build(self) -> ImageViewCreateInfo {
3771         self.inner
3772     }
3773 }
3774 #[repr(C)]
3775 #[derive(Copy, Clone, Default, Debug)]
3776 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCopy.html>"]
3777 pub struct BufferCopy {
3778     pub src_offset: DeviceSize,
3779     pub dst_offset: DeviceSize,
3780     pub size: DeviceSize,
3781 }
3782 impl BufferCopy {
builder<'a>() -> BufferCopyBuilder<'a>3783     pub fn builder<'a>() -> BufferCopyBuilder<'a> {
3784         BufferCopyBuilder {
3785             inner: BufferCopy::default(),
3786             marker: ::std::marker::PhantomData,
3787         }
3788     }
3789 }
3790 #[repr(transparent)]
3791 pub struct BufferCopyBuilder<'a> {
3792     inner: BufferCopy,
3793     marker: ::std::marker::PhantomData<&'a ()>,
3794 }
3795 impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> {
3796     type Target = BufferCopy;
deref(&self) -> &Self::Target3797     fn deref(&self) -> &Self::Target {
3798         &self.inner
3799     }
3800 }
3801 impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3802     fn deref_mut(&mut self) -> &mut Self::Target {
3803         &mut self.inner
3804     }
3805 }
3806 impl<'a> BufferCopyBuilder<'a> {
src_offset(mut self, src_offset: DeviceSize) -> BufferCopyBuilder<'a>3807     pub fn src_offset(mut self, src_offset: DeviceSize) -> BufferCopyBuilder<'a> {
3808         self.inner.src_offset = src_offset;
3809         self
3810     }
dst_offset(mut self, dst_offset: DeviceSize) -> BufferCopyBuilder<'a>3811     pub fn dst_offset(mut self, dst_offset: DeviceSize) -> BufferCopyBuilder<'a> {
3812         self.inner.dst_offset = dst_offset;
3813         self
3814     }
size(mut self, size: DeviceSize) -> BufferCopyBuilder<'a>3815     pub fn size(mut self, size: DeviceSize) -> BufferCopyBuilder<'a> {
3816         self.inner.size = size;
3817         self
3818     }
3819     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3820     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3821     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCopy3822     pub fn build(self) -> BufferCopy {
3823         self.inner
3824     }
3825 }
3826 #[repr(C)]
3827 #[derive(Copy, Clone, Default, Debug)]
3828 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBind.html>"]
3829 pub struct SparseMemoryBind {
3830     pub resource_offset: DeviceSize,
3831     pub size: DeviceSize,
3832     pub memory: DeviceMemory,
3833     pub memory_offset: DeviceSize,
3834     pub flags: SparseMemoryBindFlags,
3835 }
3836 impl SparseMemoryBind {
builder<'a>() -> SparseMemoryBindBuilder<'a>3837     pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> {
3838         SparseMemoryBindBuilder {
3839             inner: SparseMemoryBind::default(),
3840             marker: ::std::marker::PhantomData,
3841         }
3842     }
3843 }
3844 #[repr(transparent)]
3845 pub struct SparseMemoryBindBuilder<'a> {
3846     inner: SparseMemoryBind,
3847     marker: ::std::marker::PhantomData<&'a ()>,
3848 }
3849 impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> {
3850     type Target = SparseMemoryBind;
deref(&self) -> &Self::Target3851     fn deref(&self) -> &Self::Target {
3852         &self.inner
3853     }
3854 }
3855 impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3856     fn deref_mut(&mut self) -> &mut Self::Target {
3857         &mut self.inner
3858     }
3859 }
3860 impl<'a> SparseMemoryBindBuilder<'a> {
resource_offset(mut self, resource_offset: DeviceSize) -> SparseMemoryBindBuilder<'a>3861     pub fn resource_offset(mut self, resource_offset: DeviceSize) -> SparseMemoryBindBuilder<'a> {
3862         self.inner.resource_offset = resource_offset;
3863         self
3864     }
size(mut self, size: DeviceSize) -> SparseMemoryBindBuilder<'a>3865     pub fn size(mut self, size: DeviceSize) -> SparseMemoryBindBuilder<'a> {
3866         self.inner.size = size;
3867         self
3868     }
memory(mut self, memory: DeviceMemory) -> SparseMemoryBindBuilder<'a>3869     pub fn memory(mut self, memory: DeviceMemory) -> SparseMemoryBindBuilder<'a> {
3870         self.inner.memory = memory;
3871         self
3872     }
memory_offset(mut self, memory_offset: DeviceSize) -> SparseMemoryBindBuilder<'a>3873     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> SparseMemoryBindBuilder<'a> {
3874         self.inner.memory_offset = memory_offset;
3875         self
3876     }
flags(mut self, flags: SparseMemoryBindFlags) -> SparseMemoryBindBuilder<'a>3877     pub fn flags(mut self, flags: SparseMemoryBindFlags) -> SparseMemoryBindBuilder<'a> {
3878         self.inner.flags = flags;
3879         self
3880     }
3881     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3882     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3883     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseMemoryBind3884     pub fn build(self) -> SparseMemoryBind {
3885         self.inner
3886     }
3887 }
3888 #[repr(C)]
3889 #[derive(Copy, Clone, Default, Debug)]
3890 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryBind.html>"]
3891 pub struct SparseImageMemoryBind {
3892     pub subresource: ImageSubresource,
3893     pub offset: Offset3D,
3894     pub extent: Extent3D,
3895     pub memory: DeviceMemory,
3896     pub memory_offset: DeviceSize,
3897     pub flags: SparseMemoryBindFlags,
3898 }
3899 impl SparseImageMemoryBind {
builder<'a>() -> SparseImageMemoryBindBuilder<'a>3900     pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> {
3901         SparseImageMemoryBindBuilder {
3902             inner: SparseImageMemoryBind::default(),
3903             marker: ::std::marker::PhantomData,
3904         }
3905     }
3906 }
3907 #[repr(transparent)]
3908 pub struct SparseImageMemoryBindBuilder<'a> {
3909     inner: SparseImageMemoryBind,
3910     marker: ::std::marker::PhantomData<&'a ()>,
3911 }
3912 impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> {
3913     type Target = SparseImageMemoryBind;
deref(&self) -> &Self::Target3914     fn deref(&self) -> &Self::Target {
3915         &self.inner
3916     }
3917 }
3918 impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3919     fn deref_mut(&mut self) -> &mut Self::Target {
3920         &mut self.inner
3921     }
3922 }
3923 impl<'a> SparseImageMemoryBindBuilder<'a> {
subresource( mut self, subresource: ImageSubresource, ) -> SparseImageMemoryBindBuilder<'a>3924     pub fn subresource(
3925         mut self,
3926         subresource: ImageSubresource,
3927     ) -> SparseImageMemoryBindBuilder<'a> {
3928         self.inner.subresource = subresource;
3929         self
3930     }
offset(mut self, offset: Offset3D) -> SparseImageMemoryBindBuilder<'a>3931     pub fn offset(mut self, offset: Offset3D) -> SparseImageMemoryBindBuilder<'a> {
3932         self.inner.offset = offset;
3933         self
3934     }
extent(mut self, extent: Extent3D) -> SparseImageMemoryBindBuilder<'a>3935     pub fn extent(mut self, extent: Extent3D) -> SparseImageMemoryBindBuilder<'a> {
3936         self.inner.extent = extent;
3937         self
3938     }
memory(mut self, memory: DeviceMemory) -> SparseImageMemoryBindBuilder<'a>3939     pub fn memory(mut self, memory: DeviceMemory) -> SparseImageMemoryBindBuilder<'a> {
3940         self.inner.memory = memory;
3941         self
3942     }
memory_offset(mut self, memory_offset: DeviceSize) -> SparseImageMemoryBindBuilder<'a>3943     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> SparseImageMemoryBindBuilder<'a> {
3944         self.inner.memory_offset = memory_offset;
3945         self
3946     }
flags(mut self, flags: SparseMemoryBindFlags) -> SparseImageMemoryBindBuilder<'a>3947     pub fn flags(mut self, flags: SparseMemoryBindFlags) -> SparseImageMemoryBindBuilder<'a> {
3948         self.inner.flags = flags;
3949         self
3950     }
3951     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
3952     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
3953     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryBind3954     pub fn build(self) -> SparseImageMemoryBind {
3955         self.inner
3956     }
3957 }
3958 #[repr(C)]
3959 #[derive(Copy, Clone, Debug)]
3960 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseBufferMemoryBindInfo.html>"]
3961 pub struct SparseBufferMemoryBindInfo {
3962     pub buffer: Buffer,
3963     pub bind_count: u32,
3964     pub p_binds: *const SparseMemoryBind,
3965 }
3966 impl ::std::default::Default for SparseBufferMemoryBindInfo {
default() -> SparseBufferMemoryBindInfo3967     fn default() -> SparseBufferMemoryBindInfo {
3968         SparseBufferMemoryBindInfo {
3969             buffer: Buffer::default(),
3970             bind_count: u32::default(),
3971             p_binds: ::std::ptr::null(),
3972         }
3973     }
3974 }
3975 impl SparseBufferMemoryBindInfo {
builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a>3976     pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> {
3977         SparseBufferMemoryBindInfoBuilder {
3978             inner: SparseBufferMemoryBindInfo::default(),
3979             marker: ::std::marker::PhantomData,
3980         }
3981     }
3982 }
3983 #[repr(transparent)]
3984 pub struct SparseBufferMemoryBindInfoBuilder<'a> {
3985     inner: SparseBufferMemoryBindInfo,
3986     marker: ::std::marker::PhantomData<&'a ()>,
3987 }
3988 impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> {
3989     type Target = SparseBufferMemoryBindInfo;
deref(&self) -> &Self::Target3990     fn deref(&self) -> &Self::Target {
3991         &self.inner
3992     }
3993 }
3994 impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target3995     fn deref_mut(&mut self) -> &mut Self::Target {
3996         &mut self.inner
3997     }
3998 }
3999 impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
buffer(mut self, buffer: Buffer) -> SparseBufferMemoryBindInfoBuilder<'a>4000     pub fn buffer(mut self, buffer: Buffer) -> SparseBufferMemoryBindInfoBuilder<'a> {
4001         self.inner.buffer = buffer;
4002         self
4003     }
binds(mut self, binds: &'a [SparseMemoryBind]) -> SparseBufferMemoryBindInfoBuilder<'a>4004     pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> SparseBufferMemoryBindInfoBuilder<'a> {
4005         self.inner.bind_count = binds.len() as _;
4006         self.inner.p_binds = binds.as_ptr();
4007         self
4008     }
4009     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4010     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4011     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseBufferMemoryBindInfo4012     pub fn build(self) -> SparseBufferMemoryBindInfo {
4013         self.inner
4014     }
4015 }
4016 #[repr(C)]
4017 #[derive(Copy, Clone, Debug)]
4018 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html>"]
4019 pub struct SparseImageOpaqueMemoryBindInfo {
4020     pub image: Image,
4021     pub bind_count: u32,
4022     pub p_binds: *const SparseMemoryBind,
4023 }
4024 impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo {
default() -> SparseImageOpaqueMemoryBindInfo4025     fn default() -> SparseImageOpaqueMemoryBindInfo {
4026         SparseImageOpaqueMemoryBindInfo {
4027             image: Image::default(),
4028             bind_count: u32::default(),
4029             p_binds: ::std::ptr::null(),
4030         }
4031     }
4032 }
4033 impl SparseImageOpaqueMemoryBindInfo {
builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a>4034     pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4035         SparseImageOpaqueMemoryBindInfoBuilder {
4036             inner: SparseImageOpaqueMemoryBindInfo::default(),
4037             marker: ::std::marker::PhantomData,
4038         }
4039     }
4040 }
4041 #[repr(transparent)]
4042 pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4043     inner: SparseImageOpaqueMemoryBindInfo,
4044     marker: ::std::marker::PhantomData<&'a ()>,
4045 }
4046 impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4047     type Target = SparseImageOpaqueMemoryBindInfo;
deref(&self) -> &Self::Target4048     fn deref(&self) -> &Self::Target {
4049         &self.inner
4050     }
4051 }
4052 impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4053     fn deref_mut(&mut self) -> &mut Self::Target {
4054         &mut self.inner
4055     }
4056 }
4057 impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
image(mut self, image: Image) -> SparseImageOpaqueMemoryBindInfoBuilder<'a>4058     pub fn image(mut self, image: Image) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4059         self.inner.image = image;
4060         self
4061     }
binds( mut self, binds: &'a [SparseMemoryBind], ) -> SparseImageOpaqueMemoryBindInfoBuilder<'a>4062     pub fn binds(
4063         mut self,
4064         binds: &'a [SparseMemoryBind],
4065     ) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
4066         self.inner.bind_count = binds.len() as _;
4067         self.inner.p_binds = binds.as_ptr();
4068         self
4069     }
4070     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4071     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4072     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageOpaqueMemoryBindInfo4073     pub fn build(self) -> SparseImageOpaqueMemoryBindInfo {
4074         self.inner
4075     }
4076 }
4077 #[repr(C)]
4078 #[derive(Copy, Clone, Debug)]
4079 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryBindInfo.html>"]
4080 pub struct SparseImageMemoryBindInfo {
4081     pub image: Image,
4082     pub bind_count: u32,
4083     pub p_binds: *const SparseImageMemoryBind,
4084 }
4085 impl ::std::default::Default for SparseImageMemoryBindInfo {
default() -> SparseImageMemoryBindInfo4086     fn default() -> SparseImageMemoryBindInfo {
4087         SparseImageMemoryBindInfo {
4088             image: Image::default(),
4089             bind_count: u32::default(),
4090             p_binds: ::std::ptr::null(),
4091         }
4092     }
4093 }
4094 impl SparseImageMemoryBindInfo {
builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a>4095     pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> {
4096         SparseImageMemoryBindInfoBuilder {
4097             inner: SparseImageMemoryBindInfo::default(),
4098             marker: ::std::marker::PhantomData,
4099         }
4100     }
4101 }
4102 #[repr(transparent)]
4103 pub struct SparseImageMemoryBindInfoBuilder<'a> {
4104     inner: SparseImageMemoryBindInfo,
4105     marker: ::std::marker::PhantomData<&'a ()>,
4106 }
4107 impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> {
4108     type Target = SparseImageMemoryBindInfo;
deref(&self) -> &Self::Target4109     fn deref(&self) -> &Self::Target {
4110         &self.inner
4111     }
4112 }
4113 impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4114     fn deref_mut(&mut self) -> &mut Self::Target {
4115         &mut self.inner
4116     }
4117 }
4118 impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
image(mut self, image: Image) -> SparseImageMemoryBindInfoBuilder<'a>4119     pub fn image(mut self, image: Image) -> SparseImageMemoryBindInfoBuilder<'a> {
4120         self.inner.image = image;
4121         self
4122     }
binds( mut self, binds: &'a [SparseImageMemoryBind], ) -> SparseImageMemoryBindInfoBuilder<'a>4123     pub fn binds(
4124         mut self,
4125         binds: &'a [SparseImageMemoryBind],
4126     ) -> SparseImageMemoryBindInfoBuilder<'a> {
4127         self.inner.bind_count = binds.len() as _;
4128         self.inner.p_binds = binds.as_ptr();
4129         self
4130     }
4131     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4132     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4133     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryBindInfo4134     pub fn build(self) -> SparseImageMemoryBindInfo {
4135         self.inner
4136     }
4137 }
4138 #[repr(C)]
4139 #[derive(Copy, Clone, Debug)]
4140 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindSparseInfo.html>"]
4141 pub struct BindSparseInfo {
4142     pub s_type: StructureType,
4143     pub p_next: *const c_void,
4144     pub wait_semaphore_count: u32,
4145     pub p_wait_semaphores: *const Semaphore,
4146     pub buffer_bind_count: u32,
4147     pub p_buffer_binds: *const SparseBufferMemoryBindInfo,
4148     pub image_opaque_bind_count: u32,
4149     pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo,
4150     pub image_bind_count: u32,
4151     pub p_image_binds: *const SparseImageMemoryBindInfo,
4152     pub signal_semaphore_count: u32,
4153     pub p_signal_semaphores: *const Semaphore,
4154 }
4155 impl ::std::default::Default for BindSparseInfo {
default() -> BindSparseInfo4156     fn default() -> BindSparseInfo {
4157         BindSparseInfo {
4158             s_type: StructureType::BIND_SPARSE_INFO,
4159             p_next: ::std::ptr::null(),
4160             wait_semaphore_count: u32::default(),
4161             p_wait_semaphores: ::std::ptr::null(),
4162             buffer_bind_count: u32::default(),
4163             p_buffer_binds: ::std::ptr::null(),
4164             image_opaque_bind_count: u32::default(),
4165             p_image_opaque_binds: ::std::ptr::null(),
4166             image_bind_count: u32::default(),
4167             p_image_binds: ::std::ptr::null(),
4168             signal_semaphore_count: u32::default(),
4169             p_signal_semaphores: ::std::ptr::null(),
4170         }
4171     }
4172 }
4173 impl BindSparseInfo {
builder<'a>() -> BindSparseInfoBuilder<'a>4174     pub fn builder<'a>() -> BindSparseInfoBuilder<'a> {
4175         BindSparseInfoBuilder {
4176             inner: BindSparseInfo::default(),
4177             marker: ::std::marker::PhantomData,
4178         }
4179     }
4180 }
4181 #[repr(transparent)]
4182 pub struct BindSparseInfoBuilder<'a> {
4183     inner: BindSparseInfo,
4184     marker: ::std::marker::PhantomData<&'a ()>,
4185 }
4186 pub unsafe trait ExtendsBindSparseInfo {}
4187 impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> {
4188     type Target = BindSparseInfo;
deref(&self) -> &Self::Target4189     fn deref(&self) -> &Self::Target {
4190         &self.inner
4191     }
4192 }
4193 impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4194     fn deref_mut(&mut self) -> &mut Self::Target {
4195         &mut self.inner
4196     }
4197 }
4198 impl<'a> BindSparseInfoBuilder<'a> {
wait_semaphores( mut self, wait_semaphores: &'a [Semaphore], ) -> BindSparseInfoBuilder<'a>4199     pub fn wait_semaphores(
4200         mut self,
4201         wait_semaphores: &'a [Semaphore],
4202     ) -> BindSparseInfoBuilder<'a> {
4203         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
4204         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
4205         self
4206     }
buffer_binds( mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo], ) -> BindSparseInfoBuilder<'a>4207     pub fn buffer_binds(
4208         mut self,
4209         buffer_binds: &'a [SparseBufferMemoryBindInfo],
4210     ) -> BindSparseInfoBuilder<'a> {
4211         self.inner.buffer_bind_count = buffer_binds.len() as _;
4212         self.inner.p_buffer_binds = buffer_binds.as_ptr();
4213         self
4214     }
image_opaque_binds( mut self, image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo], ) -> BindSparseInfoBuilder<'a>4215     pub fn image_opaque_binds(
4216         mut self,
4217         image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo],
4218     ) -> BindSparseInfoBuilder<'a> {
4219         self.inner.image_opaque_bind_count = image_opaque_binds.len() as _;
4220         self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr();
4221         self
4222     }
image_binds( mut self, image_binds: &'a [SparseImageMemoryBindInfo], ) -> BindSparseInfoBuilder<'a>4223     pub fn image_binds(
4224         mut self,
4225         image_binds: &'a [SparseImageMemoryBindInfo],
4226     ) -> BindSparseInfoBuilder<'a> {
4227         self.inner.image_bind_count = image_binds.len() as _;
4228         self.inner.p_image_binds = image_binds.as_ptr();
4229         self
4230     }
signal_semaphores( mut self, signal_semaphores: &'a [Semaphore], ) -> BindSparseInfoBuilder<'a>4231     pub fn signal_semaphores(
4232         mut self,
4233         signal_semaphores: &'a [Semaphore],
4234     ) -> BindSparseInfoBuilder<'a> {
4235         self.inner.signal_semaphore_count = signal_semaphores.len() as _;
4236         self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
4237         self
4238     }
4239     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4240     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4241     #[doc = r" valid extension structs can be pushed into the chain."]
4242     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4243     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBindSparseInfo>( mut self, next: &'a mut T, ) -> BindSparseInfoBuilder<'a>4244     pub fn push_next<T: ExtendsBindSparseInfo>(
4245         mut self,
4246         next: &'a mut T,
4247     ) -> BindSparseInfoBuilder<'a> {
4248         unsafe {
4249             let next_ptr = next as *mut T as *mut BaseOutStructure;
4250             let last_next = ptr_chain_iter(next).last().unwrap();
4251             (*last_next).p_next = self.inner.p_next as _;
4252             self.inner.p_next = next_ptr as _;
4253         }
4254         self
4255     }
4256     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4257     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4258     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindSparseInfo4259     pub fn build(self) -> BindSparseInfo {
4260         self.inner
4261     }
4262 }
4263 #[repr(C)]
4264 #[derive(Copy, Clone, Default, Debug)]
4265 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCopy.html>"]
4266 pub struct ImageCopy {
4267     pub src_subresource: ImageSubresourceLayers,
4268     pub src_offset: Offset3D,
4269     pub dst_subresource: ImageSubresourceLayers,
4270     pub dst_offset: Offset3D,
4271     pub extent: Extent3D,
4272 }
4273 impl ImageCopy {
builder<'a>() -> ImageCopyBuilder<'a>4274     pub fn builder<'a>() -> ImageCopyBuilder<'a> {
4275         ImageCopyBuilder {
4276             inner: ImageCopy::default(),
4277             marker: ::std::marker::PhantomData,
4278         }
4279     }
4280 }
4281 #[repr(transparent)]
4282 pub struct ImageCopyBuilder<'a> {
4283     inner: ImageCopy,
4284     marker: ::std::marker::PhantomData<&'a ()>,
4285 }
4286 impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> {
4287     type Target = ImageCopy;
deref(&self) -> &Self::Target4288     fn deref(&self) -> &Self::Target {
4289         &self.inner
4290     }
4291 }
4292 impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4293     fn deref_mut(&mut self) -> &mut Self::Target {
4294         &mut self.inner
4295     }
4296 }
4297 impl<'a> ImageCopyBuilder<'a> {
src_subresource( mut self, src_subresource: ImageSubresourceLayers, ) -> ImageCopyBuilder<'a>4298     pub fn src_subresource(
4299         mut self,
4300         src_subresource: ImageSubresourceLayers,
4301     ) -> ImageCopyBuilder<'a> {
4302         self.inner.src_subresource = src_subresource;
4303         self
4304     }
src_offset(mut self, src_offset: Offset3D) -> ImageCopyBuilder<'a>4305     pub fn src_offset(mut self, src_offset: Offset3D) -> ImageCopyBuilder<'a> {
4306         self.inner.src_offset = src_offset;
4307         self
4308     }
dst_subresource( mut self, dst_subresource: ImageSubresourceLayers, ) -> ImageCopyBuilder<'a>4309     pub fn dst_subresource(
4310         mut self,
4311         dst_subresource: ImageSubresourceLayers,
4312     ) -> ImageCopyBuilder<'a> {
4313         self.inner.dst_subresource = dst_subresource;
4314         self
4315     }
dst_offset(mut self, dst_offset: Offset3D) -> ImageCopyBuilder<'a>4316     pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageCopyBuilder<'a> {
4317         self.inner.dst_offset = dst_offset;
4318         self
4319     }
extent(mut self, extent: Extent3D) -> ImageCopyBuilder<'a>4320     pub fn extent(mut self, extent: Extent3D) -> ImageCopyBuilder<'a> {
4321         self.inner.extent = extent;
4322         self
4323     }
4324     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4325     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4326     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCopy4327     pub fn build(self) -> ImageCopy {
4328         self.inner
4329     }
4330 }
4331 #[repr(C)]
4332 #[derive(Copy, Clone, Debug)]
4333 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageBlit.html>"]
4334 pub struct ImageBlit {
4335     pub src_subresource: ImageSubresourceLayers,
4336     pub src_offsets: [Offset3D; 2],
4337     pub dst_subresource: ImageSubresourceLayers,
4338     pub dst_offsets: [Offset3D; 2],
4339 }
4340 impl ::std::default::Default for ImageBlit {
default() -> ImageBlit4341     fn default() -> ImageBlit {
4342         ImageBlit {
4343             src_subresource: ImageSubresourceLayers::default(),
4344             src_offsets: unsafe { ::std::mem::zeroed() },
4345             dst_subresource: ImageSubresourceLayers::default(),
4346             dst_offsets: unsafe { ::std::mem::zeroed() },
4347         }
4348     }
4349 }
4350 impl ImageBlit {
builder<'a>() -> ImageBlitBuilder<'a>4351     pub fn builder<'a>() -> ImageBlitBuilder<'a> {
4352         ImageBlitBuilder {
4353             inner: ImageBlit::default(),
4354             marker: ::std::marker::PhantomData,
4355         }
4356     }
4357 }
4358 #[repr(transparent)]
4359 pub struct ImageBlitBuilder<'a> {
4360     inner: ImageBlit,
4361     marker: ::std::marker::PhantomData<&'a ()>,
4362 }
4363 impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> {
4364     type Target = ImageBlit;
deref(&self) -> &Self::Target4365     fn deref(&self) -> &Self::Target {
4366         &self.inner
4367     }
4368 }
4369 impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4370     fn deref_mut(&mut self) -> &mut Self::Target {
4371         &mut self.inner
4372     }
4373 }
4374 impl<'a> ImageBlitBuilder<'a> {
src_subresource( mut self, src_subresource: ImageSubresourceLayers, ) -> ImageBlitBuilder<'a>4375     pub fn src_subresource(
4376         mut self,
4377         src_subresource: ImageSubresourceLayers,
4378     ) -> ImageBlitBuilder<'a> {
4379         self.inner.src_subresource = src_subresource;
4380         self
4381     }
src_offsets(mut self, src_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a>4382     pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a> {
4383         self.inner.src_offsets = src_offsets;
4384         self
4385     }
dst_subresource( mut self, dst_subresource: ImageSubresourceLayers, ) -> ImageBlitBuilder<'a>4386     pub fn dst_subresource(
4387         mut self,
4388         dst_subresource: ImageSubresourceLayers,
4389     ) -> ImageBlitBuilder<'a> {
4390         self.inner.dst_subresource = dst_subresource;
4391         self
4392     }
dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a>4393     pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a> {
4394         self.inner.dst_offsets = dst_offsets;
4395         self
4396     }
4397     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4398     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4399     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageBlit4400     pub fn build(self) -> ImageBlit {
4401         self.inner
4402     }
4403 }
4404 #[repr(C)]
4405 #[derive(Copy, Clone, Default, Debug)]
4406 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferImageCopy.html>"]
4407 pub struct BufferImageCopy {
4408     pub buffer_offset: DeviceSize,
4409     pub buffer_row_length: u32,
4410     pub buffer_image_height: u32,
4411     pub image_subresource: ImageSubresourceLayers,
4412     pub image_offset: Offset3D,
4413     pub image_extent: Extent3D,
4414 }
4415 impl BufferImageCopy {
builder<'a>() -> BufferImageCopyBuilder<'a>4416     pub fn builder<'a>() -> BufferImageCopyBuilder<'a> {
4417         BufferImageCopyBuilder {
4418             inner: BufferImageCopy::default(),
4419             marker: ::std::marker::PhantomData,
4420         }
4421     }
4422 }
4423 #[repr(transparent)]
4424 pub struct BufferImageCopyBuilder<'a> {
4425     inner: BufferImageCopy,
4426     marker: ::std::marker::PhantomData<&'a ()>,
4427 }
4428 impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> {
4429     type Target = BufferImageCopy;
deref(&self) -> &Self::Target4430     fn deref(&self) -> &Self::Target {
4431         &self.inner
4432     }
4433 }
4434 impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4435     fn deref_mut(&mut self) -> &mut Self::Target {
4436         &mut self.inner
4437     }
4438 }
4439 impl<'a> BufferImageCopyBuilder<'a> {
buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopyBuilder<'a>4440     pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopyBuilder<'a> {
4441         self.inner.buffer_offset = buffer_offset;
4442         self
4443     }
buffer_row_length(mut self, buffer_row_length: u32) -> BufferImageCopyBuilder<'a>4444     pub fn buffer_row_length(mut self, buffer_row_length: u32) -> BufferImageCopyBuilder<'a> {
4445         self.inner.buffer_row_length = buffer_row_length;
4446         self
4447     }
buffer_image_height(mut self, buffer_image_height: u32) -> BufferImageCopyBuilder<'a>4448     pub fn buffer_image_height(mut self, buffer_image_height: u32) -> BufferImageCopyBuilder<'a> {
4449         self.inner.buffer_image_height = buffer_image_height;
4450         self
4451     }
image_subresource( mut self, image_subresource: ImageSubresourceLayers, ) -> BufferImageCopyBuilder<'a>4452     pub fn image_subresource(
4453         mut self,
4454         image_subresource: ImageSubresourceLayers,
4455     ) -> BufferImageCopyBuilder<'a> {
4456         self.inner.image_subresource = image_subresource;
4457         self
4458     }
image_offset(mut self, image_offset: Offset3D) -> BufferImageCopyBuilder<'a>4459     pub fn image_offset(mut self, image_offset: Offset3D) -> BufferImageCopyBuilder<'a> {
4460         self.inner.image_offset = image_offset;
4461         self
4462     }
image_extent(mut self, image_extent: Extent3D) -> BufferImageCopyBuilder<'a>4463     pub fn image_extent(mut self, image_extent: Extent3D) -> BufferImageCopyBuilder<'a> {
4464         self.inner.image_extent = image_extent;
4465         self
4466     }
4467     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4468     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4469     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferImageCopy4470     pub fn build(self) -> BufferImageCopy {
4471         self.inner
4472     }
4473 }
4474 #[repr(C)]
4475 #[derive(Copy, Clone, Default, Debug)]
4476 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageResolve.html>"]
4477 pub struct ImageResolve {
4478     pub src_subresource: ImageSubresourceLayers,
4479     pub src_offset: Offset3D,
4480     pub dst_subresource: ImageSubresourceLayers,
4481     pub dst_offset: Offset3D,
4482     pub extent: Extent3D,
4483 }
4484 impl ImageResolve {
builder<'a>() -> ImageResolveBuilder<'a>4485     pub fn builder<'a>() -> ImageResolveBuilder<'a> {
4486         ImageResolveBuilder {
4487             inner: ImageResolve::default(),
4488             marker: ::std::marker::PhantomData,
4489         }
4490     }
4491 }
4492 #[repr(transparent)]
4493 pub struct ImageResolveBuilder<'a> {
4494     inner: ImageResolve,
4495     marker: ::std::marker::PhantomData<&'a ()>,
4496 }
4497 impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> {
4498     type Target = ImageResolve;
deref(&self) -> &Self::Target4499     fn deref(&self) -> &Self::Target {
4500         &self.inner
4501     }
4502 }
4503 impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4504     fn deref_mut(&mut self) -> &mut Self::Target {
4505         &mut self.inner
4506     }
4507 }
4508 impl<'a> ImageResolveBuilder<'a> {
src_subresource( mut self, src_subresource: ImageSubresourceLayers, ) -> ImageResolveBuilder<'a>4509     pub fn src_subresource(
4510         mut self,
4511         src_subresource: ImageSubresourceLayers,
4512     ) -> ImageResolveBuilder<'a> {
4513         self.inner.src_subresource = src_subresource;
4514         self
4515     }
src_offset(mut self, src_offset: Offset3D) -> ImageResolveBuilder<'a>4516     pub fn src_offset(mut self, src_offset: Offset3D) -> ImageResolveBuilder<'a> {
4517         self.inner.src_offset = src_offset;
4518         self
4519     }
dst_subresource( mut self, dst_subresource: ImageSubresourceLayers, ) -> ImageResolveBuilder<'a>4520     pub fn dst_subresource(
4521         mut self,
4522         dst_subresource: ImageSubresourceLayers,
4523     ) -> ImageResolveBuilder<'a> {
4524         self.inner.dst_subresource = dst_subresource;
4525         self
4526     }
dst_offset(mut self, dst_offset: Offset3D) -> ImageResolveBuilder<'a>4527     pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageResolveBuilder<'a> {
4528         self.inner.dst_offset = dst_offset;
4529         self
4530     }
extent(mut self, extent: Extent3D) -> ImageResolveBuilder<'a>4531     pub fn extent(mut self, extent: Extent3D) -> ImageResolveBuilder<'a> {
4532         self.inner.extent = extent;
4533         self
4534     }
4535     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4536     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4537     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageResolve4538     pub fn build(self) -> ImageResolve {
4539         self.inner
4540     }
4541 }
4542 #[repr(C)]
4543 #[derive(Copy, Clone, Debug)]
4544 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateInfo.html>"]
4545 pub struct ShaderModuleCreateInfo {
4546     pub s_type: StructureType,
4547     pub p_next: *const c_void,
4548     pub flags: ShaderModuleCreateFlags,
4549     pub code_size: usize,
4550     pub p_code: *const u32,
4551 }
4552 impl ::std::default::Default for ShaderModuleCreateInfo {
default() -> ShaderModuleCreateInfo4553     fn default() -> ShaderModuleCreateInfo {
4554         ShaderModuleCreateInfo {
4555             s_type: StructureType::SHADER_MODULE_CREATE_INFO,
4556             p_next: ::std::ptr::null(),
4557             flags: ShaderModuleCreateFlags::default(),
4558             code_size: usize::default(),
4559             p_code: ::std::ptr::null(),
4560         }
4561     }
4562 }
4563 impl ShaderModuleCreateInfo {
builder<'a>() -> ShaderModuleCreateInfoBuilder<'a>4564     pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> {
4565         ShaderModuleCreateInfoBuilder {
4566             inner: ShaderModuleCreateInfo::default(),
4567             marker: ::std::marker::PhantomData,
4568         }
4569     }
4570 }
4571 #[repr(transparent)]
4572 pub struct ShaderModuleCreateInfoBuilder<'a> {
4573     inner: ShaderModuleCreateInfo,
4574     marker: ::std::marker::PhantomData<&'a ()>,
4575 }
4576 pub unsafe trait ExtendsShaderModuleCreateInfo {}
4577 impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
4578     type Target = ShaderModuleCreateInfo;
deref(&self) -> &Self::Target4579     fn deref(&self) -> &Self::Target {
4580         &self.inner
4581     }
4582 }
4583 impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4584     fn deref_mut(&mut self) -> &mut Self::Target {
4585         &mut self.inner
4586     }
4587 }
4588 impl<'a> ShaderModuleCreateInfoBuilder<'a> {
flags(mut self, flags: ShaderModuleCreateFlags) -> ShaderModuleCreateInfoBuilder<'a>4589     pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> ShaderModuleCreateInfoBuilder<'a> {
4590         self.inner.flags = flags;
4591         self
4592     }
code(mut self, code: &'a [u32]) -> ShaderModuleCreateInfoBuilder<'a>4593     pub fn code(mut self, code: &'a [u32]) -> ShaderModuleCreateInfoBuilder<'a> {
4594         self.inner.code_size = code.len() * 4;
4595         self.inner.p_code = code.as_ptr() as *const u32;
4596         self
4597     }
4598     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4599     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4600     #[doc = r" valid extension structs can be pushed into the chain."]
4601     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4602     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsShaderModuleCreateInfo>( mut self, next: &'a mut T, ) -> ShaderModuleCreateInfoBuilder<'a>4603     pub fn push_next<T: ExtendsShaderModuleCreateInfo>(
4604         mut self,
4605         next: &'a mut T,
4606     ) -> ShaderModuleCreateInfoBuilder<'a> {
4607         unsafe {
4608             let next_ptr = next as *mut T as *mut BaseOutStructure;
4609             let last_next = ptr_chain_iter(next).last().unwrap();
4610             (*last_next).p_next = self.inner.p_next as _;
4611             self.inner.p_next = next_ptr as _;
4612         }
4613         self
4614     }
4615     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4616     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4617     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderModuleCreateInfo4618     pub fn build(self) -> ShaderModuleCreateInfo {
4619         self.inner
4620     }
4621 }
4622 #[repr(C)]
4623 #[derive(Copy, Clone, Debug)]
4624 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutBinding.html>"]
4625 pub struct DescriptorSetLayoutBinding {
4626     pub binding: u32,
4627     pub descriptor_type: DescriptorType,
4628     pub descriptor_count: u32,
4629     pub stage_flags: ShaderStageFlags,
4630     pub p_immutable_samplers: *const Sampler,
4631 }
4632 impl ::std::default::Default for DescriptorSetLayoutBinding {
default() -> DescriptorSetLayoutBinding4633     fn default() -> DescriptorSetLayoutBinding {
4634         DescriptorSetLayoutBinding {
4635             binding: u32::default(),
4636             descriptor_type: DescriptorType::default(),
4637             descriptor_count: u32::default(),
4638             stage_flags: ShaderStageFlags::default(),
4639             p_immutable_samplers: ::std::ptr::null(),
4640         }
4641     }
4642 }
4643 impl DescriptorSetLayoutBinding {
builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a>4644     pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> {
4645         DescriptorSetLayoutBindingBuilder {
4646             inner: DescriptorSetLayoutBinding::default(),
4647             marker: ::std::marker::PhantomData,
4648         }
4649     }
4650 }
4651 #[repr(transparent)]
4652 pub struct DescriptorSetLayoutBindingBuilder<'a> {
4653     inner: DescriptorSetLayoutBinding,
4654     marker: ::std::marker::PhantomData<&'a ()>,
4655 }
4656 impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> {
4657     type Target = DescriptorSetLayoutBinding;
deref(&self) -> &Self::Target4658     fn deref(&self) -> &Self::Target {
4659         &self.inner
4660     }
4661 }
4662 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4663     fn deref_mut(&mut self) -> &mut Self::Target {
4664         &mut self.inner
4665     }
4666 }
4667 impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
binding(mut self, binding: u32) -> DescriptorSetLayoutBindingBuilder<'a>4668     pub fn binding(mut self, binding: u32) -> DescriptorSetLayoutBindingBuilder<'a> {
4669         self.inner.binding = binding;
4670         self
4671     }
descriptor_type( mut self, descriptor_type: DescriptorType, ) -> DescriptorSetLayoutBindingBuilder<'a>4672     pub fn descriptor_type(
4673         mut self,
4674         descriptor_type: DescriptorType,
4675     ) -> DescriptorSetLayoutBindingBuilder<'a> {
4676         self.inner.descriptor_type = descriptor_type;
4677         self
4678     }
descriptor_count( mut self, descriptor_count: u32, ) -> DescriptorSetLayoutBindingBuilder<'a>4679     pub fn descriptor_count(
4680         mut self,
4681         descriptor_count: u32,
4682     ) -> DescriptorSetLayoutBindingBuilder<'a> {
4683         self.inner.descriptor_count = descriptor_count;
4684         self
4685     }
stage_flags( mut self, stage_flags: ShaderStageFlags, ) -> DescriptorSetLayoutBindingBuilder<'a>4686     pub fn stage_flags(
4687         mut self,
4688         stage_flags: ShaderStageFlags,
4689     ) -> DescriptorSetLayoutBindingBuilder<'a> {
4690         self.inner.stage_flags = stage_flags;
4691         self
4692     }
immutable_samplers( mut self, immutable_samplers: &'a [Sampler], ) -> DescriptorSetLayoutBindingBuilder<'a>4693     pub fn immutable_samplers(
4694         mut self,
4695         immutable_samplers: &'a [Sampler],
4696     ) -> DescriptorSetLayoutBindingBuilder<'a> {
4697         self.inner.descriptor_count = immutable_samplers.len() as _;
4698         self.inner.p_immutable_samplers = immutable_samplers.as_ptr();
4699         self
4700     }
4701     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4702     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4703     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutBinding4704     pub fn build(self) -> DescriptorSetLayoutBinding {
4705         self.inner
4706     }
4707 }
4708 #[repr(C)]
4709 #[derive(Copy, Clone, Debug)]
4710 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html>"]
4711 pub struct DescriptorSetLayoutCreateInfo {
4712     pub s_type: StructureType,
4713     pub p_next: *const c_void,
4714     pub flags: DescriptorSetLayoutCreateFlags,
4715     pub binding_count: u32,
4716     pub p_bindings: *const DescriptorSetLayoutBinding,
4717 }
4718 impl ::std::default::Default for DescriptorSetLayoutCreateInfo {
default() -> DescriptorSetLayoutCreateInfo4719     fn default() -> DescriptorSetLayoutCreateInfo {
4720         DescriptorSetLayoutCreateInfo {
4721             s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
4722             p_next: ::std::ptr::null(),
4723             flags: DescriptorSetLayoutCreateFlags::default(),
4724             binding_count: u32::default(),
4725             p_bindings: ::std::ptr::null(),
4726         }
4727     }
4728 }
4729 impl DescriptorSetLayoutCreateInfo {
builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a>4730     pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
4731         DescriptorSetLayoutCreateInfoBuilder {
4732             inner: DescriptorSetLayoutCreateInfo::default(),
4733             marker: ::std::marker::PhantomData,
4734         }
4735     }
4736 }
4737 #[repr(transparent)]
4738 pub struct DescriptorSetLayoutCreateInfoBuilder<'a> {
4739     inner: DescriptorSetLayoutCreateInfo,
4740     marker: ::std::marker::PhantomData<&'a ()>,
4741 }
4742 pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {}
4743 impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
4744     type Target = DescriptorSetLayoutCreateInfo;
deref(&self) -> &Self::Target4745     fn deref(&self) -> &Self::Target {
4746         &self.inner
4747     }
4748 }
4749 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4750     fn deref_mut(&mut self) -> &mut Self::Target {
4751         &mut self.inner
4752     }
4753 }
4754 impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
flags( mut self, flags: DescriptorSetLayoutCreateFlags, ) -> DescriptorSetLayoutCreateInfoBuilder<'a>4755     pub fn flags(
4756         mut self,
4757         flags: DescriptorSetLayoutCreateFlags,
4758     ) -> DescriptorSetLayoutCreateInfoBuilder<'a> {
4759         self.inner.flags = flags;
4760         self
4761     }
bindings( mut self, bindings: &'a [DescriptorSetLayoutBinding], ) -> DescriptorSetLayoutCreateInfoBuilder<'a>4762     pub fn bindings(
4763         mut self,
4764         bindings: &'a [DescriptorSetLayoutBinding],
4765     ) -> DescriptorSetLayoutCreateInfoBuilder<'a> {
4766         self.inner.binding_count = bindings.len() as _;
4767         self.inner.p_bindings = bindings.as_ptr();
4768         self
4769     }
4770     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4771     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4772     #[doc = r" valid extension structs can be pushed into the chain."]
4773     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4774     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorSetLayoutCreateInfo>( mut self, next: &'a mut T, ) -> DescriptorSetLayoutCreateInfoBuilder<'a>4775     pub fn push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(
4776         mut self,
4777         next: &'a mut T,
4778     ) -> DescriptorSetLayoutCreateInfoBuilder<'a> {
4779         unsafe {
4780             let next_ptr = next as *mut T as *mut BaseOutStructure;
4781             let last_next = ptr_chain_iter(next).last().unwrap();
4782             (*last_next).p_next = self.inner.p_next as _;
4783             self.inner.p_next = next_ptr as _;
4784         }
4785         self
4786     }
4787     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4788     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4789     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutCreateInfo4790     pub fn build(self) -> DescriptorSetLayoutCreateInfo {
4791         self.inner
4792     }
4793 }
4794 #[repr(C)]
4795 #[derive(Copy, Clone, Default, Debug)]
4796 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolSize.html>"]
4797 pub struct DescriptorPoolSize {
4798     pub ty: DescriptorType,
4799     pub descriptor_count: u32,
4800 }
4801 impl DescriptorPoolSize {
builder<'a>() -> DescriptorPoolSizeBuilder<'a>4802     pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> {
4803         DescriptorPoolSizeBuilder {
4804             inner: DescriptorPoolSize::default(),
4805             marker: ::std::marker::PhantomData,
4806         }
4807     }
4808 }
4809 #[repr(transparent)]
4810 pub struct DescriptorPoolSizeBuilder<'a> {
4811     inner: DescriptorPoolSize,
4812     marker: ::std::marker::PhantomData<&'a ()>,
4813 }
4814 impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> {
4815     type Target = DescriptorPoolSize;
deref(&self) -> &Self::Target4816     fn deref(&self) -> &Self::Target {
4817         &self.inner
4818     }
4819 }
4820 impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4821     fn deref_mut(&mut self) -> &mut Self::Target {
4822         &mut self.inner
4823     }
4824 }
4825 impl<'a> DescriptorPoolSizeBuilder<'a> {
ty(mut self, ty: DescriptorType) -> DescriptorPoolSizeBuilder<'a>4826     pub fn ty(mut self, ty: DescriptorType) -> DescriptorPoolSizeBuilder<'a> {
4827         self.inner.ty = ty;
4828         self
4829     }
descriptor_count(mut self, descriptor_count: u32) -> DescriptorPoolSizeBuilder<'a>4830     pub fn descriptor_count(mut self, descriptor_count: u32) -> DescriptorPoolSizeBuilder<'a> {
4831         self.inner.descriptor_count = descriptor_count;
4832         self
4833     }
4834     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4835     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4836     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorPoolSize4837     pub fn build(self) -> DescriptorPoolSize {
4838         self.inner
4839     }
4840 }
4841 #[repr(C)]
4842 #[derive(Copy, Clone, Debug)]
4843 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateInfo.html>"]
4844 pub struct DescriptorPoolCreateInfo {
4845     pub s_type: StructureType,
4846     pub p_next: *const c_void,
4847     pub flags: DescriptorPoolCreateFlags,
4848     pub max_sets: u32,
4849     pub pool_size_count: u32,
4850     pub p_pool_sizes: *const DescriptorPoolSize,
4851 }
4852 impl ::std::default::Default for DescriptorPoolCreateInfo {
default() -> DescriptorPoolCreateInfo4853     fn default() -> DescriptorPoolCreateInfo {
4854         DescriptorPoolCreateInfo {
4855             s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO,
4856             p_next: ::std::ptr::null(),
4857             flags: DescriptorPoolCreateFlags::default(),
4858             max_sets: u32::default(),
4859             pool_size_count: u32::default(),
4860             p_pool_sizes: ::std::ptr::null(),
4861         }
4862     }
4863 }
4864 impl DescriptorPoolCreateInfo {
builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a>4865     pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> {
4866         DescriptorPoolCreateInfoBuilder {
4867             inner: DescriptorPoolCreateInfo::default(),
4868             marker: ::std::marker::PhantomData,
4869         }
4870     }
4871 }
4872 #[repr(transparent)]
4873 pub struct DescriptorPoolCreateInfoBuilder<'a> {
4874     inner: DescriptorPoolCreateInfo,
4875     marker: ::std::marker::PhantomData<&'a ()>,
4876 }
4877 pub unsafe trait ExtendsDescriptorPoolCreateInfo {}
4878 impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> {
4879     type Target = DescriptorPoolCreateInfo;
deref(&self) -> &Self::Target4880     fn deref(&self) -> &Self::Target {
4881         &self.inner
4882     }
4883 }
4884 impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4885     fn deref_mut(&mut self) -> &mut Self::Target {
4886         &mut self.inner
4887     }
4888 }
4889 impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
flags( mut self, flags: DescriptorPoolCreateFlags, ) -> DescriptorPoolCreateInfoBuilder<'a>4890     pub fn flags(
4891         mut self,
4892         flags: DescriptorPoolCreateFlags,
4893     ) -> DescriptorPoolCreateInfoBuilder<'a> {
4894         self.inner.flags = flags;
4895         self
4896     }
max_sets(mut self, max_sets: u32) -> DescriptorPoolCreateInfoBuilder<'a>4897     pub fn max_sets(mut self, max_sets: u32) -> DescriptorPoolCreateInfoBuilder<'a> {
4898         self.inner.max_sets = max_sets;
4899         self
4900     }
pool_sizes( mut self, pool_sizes: &'a [DescriptorPoolSize], ) -> DescriptorPoolCreateInfoBuilder<'a>4901     pub fn pool_sizes(
4902         mut self,
4903         pool_sizes: &'a [DescriptorPoolSize],
4904     ) -> DescriptorPoolCreateInfoBuilder<'a> {
4905         self.inner.pool_size_count = pool_sizes.len() as _;
4906         self.inner.p_pool_sizes = pool_sizes.as_ptr();
4907         self
4908     }
4909     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4910     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4911     #[doc = r" valid extension structs can be pushed into the chain."]
4912     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4913     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorPoolCreateInfo>( mut self, next: &'a mut T, ) -> DescriptorPoolCreateInfoBuilder<'a>4914     pub fn push_next<T: ExtendsDescriptorPoolCreateInfo>(
4915         mut self,
4916         next: &'a mut T,
4917     ) -> DescriptorPoolCreateInfoBuilder<'a> {
4918         unsafe {
4919             let next_ptr = next as *mut T as *mut BaseOutStructure;
4920             let last_next = ptr_chain_iter(next).last().unwrap();
4921             (*last_next).p_next = self.inner.p_next as _;
4922             self.inner.p_next = next_ptr as _;
4923         }
4924         self
4925     }
4926     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
4927     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
4928     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorPoolCreateInfo4929     pub fn build(self) -> DescriptorPoolCreateInfo {
4930         self.inner
4931     }
4932 }
4933 #[repr(C)]
4934 #[derive(Copy, Clone, Debug)]
4935 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetAllocateInfo.html>"]
4936 pub struct DescriptorSetAllocateInfo {
4937     pub s_type: StructureType,
4938     pub p_next: *const c_void,
4939     pub descriptor_pool: DescriptorPool,
4940     pub descriptor_set_count: u32,
4941     pub p_set_layouts: *const DescriptorSetLayout,
4942 }
4943 impl ::std::default::Default for DescriptorSetAllocateInfo {
default() -> DescriptorSetAllocateInfo4944     fn default() -> DescriptorSetAllocateInfo {
4945         DescriptorSetAllocateInfo {
4946             s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO,
4947             p_next: ::std::ptr::null(),
4948             descriptor_pool: DescriptorPool::default(),
4949             descriptor_set_count: u32::default(),
4950             p_set_layouts: ::std::ptr::null(),
4951         }
4952     }
4953 }
4954 impl DescriptorSetAllocateInfo {
builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a>4955     pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> {
4956         DescriptorSetAllocateInfoBuilder {
4957             inner: DescriptorSetAllocateInfo::default(),
4958             marker: ::std::marker::PhantomData,
4959         }
4960     }
4961 }
4962 #[repr(transparent)]
4963 pub struct DescriptorSetAllocateInfoBuilder<'a> {
4964     inner: DescriptorSetAllocateInfo,
4965     marker: ::std::marker::PhantomData<&'a ()>,
4966 }
4967 pub unsafe trait ExtendsDescriptorSetAllocateInfo {}
4968 impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> {
4969     type Target = DescriptorSetAllocateInfo;
deref(&self) -> &Self::Target4970     fn deref(&self) -> &Self::Target {
4971         &self.inner
4972     }
4973 }
4974 impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target4975     fn deref_mut(&mut self) -> &mut Self::Target {
4976         &mut self.inner
4977     }
4978 }
4979 impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
descriptor_pool( mut self, descriptor_pool: DescriptorPool, ) -> DescriptorSetAllocateInfoBuilder<'a>4980     pub fn descriptor_pool(
4981         mut self,
4982         descriptor_pool: DescriptorPool,
4983     ) -> DescriptorSetAllocateInfoBuilder<'a> {
4984         self.inner.descriptor_pool = descriptor_pool;
4985         self
4986     }
set_layouts( mut self, set_layouts: &'a [DescriptorSetLayout], ) -> DescriptorSetAllocateInfoBuilder<'a>4987     pub fn set_layouts(
4988         mut self,
4989         set_layouts: &'a [DescriptorSetLayout],
4990     ) -> DescriptorSetAllocateInfoBuilder<'a> {
4991         self.inner.descriptor_set_count = set_layouts.len() as _;
4992         self.inner.p_set_layouts = set_layouts.as_ptr();
4993         self
4994     }
4995     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
4996     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
4997     #[doc = r" valid extension structs can be pushed into the chain."]
4998     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
4999     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorSetAllocateInfo>( mut self, next: &'a mut T, ) -> DescriptorSetAllocateInfoBuilder<'a>5000     pub fn push_next<T: ExtendsDescriptorSetAllocateInfo>(
5001         mut self,
5002         next: &'a mut T,
5003     ) -> DescriptorSetAllocateInfoBuilder<'a> {
5004         unsafe {
5005             let next_ptr = next as *mut T as *mut BaseOutStructure;
5006             let last_next = ptr_chain_iter(next).last().unwrap();
5007             (*last_next).p_next = self.inner.p_next as _;
5008             self.inner.p_next = next_ptr as _;
5009         }
5010         self
5011     }
5012     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5013     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5014     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetAllocateInfo5015     pub fn build(self) -> DescriptorSetAllocateInfo {
5016         self.inner
5017     }
5018 }
5019 #[repr(C)]
5020 #[derive(Copy, Clone, Default, Debug)]
5021 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSpecializationMapEntry.html>"]
5022 pub struct SpecializationMapEntry {
5023     pub constant_id: u32,
5024     pub offset: u32,
5025     pub size: usize,
5026 }
5027 impl SpecializationMapEntry {
builder<'a>() -> SpecializationMapEntryBuilder<'a>5028     pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> {
5029         SpecializationMapEntryBuilder {
5030             inner: SpecializationMapEntry::default(),
5031             marker: ::std::marker::PhantomData,
5032         }
5033     }
5034 }
5035 #[repr(transparent)]
5036 pub struct SpecializationMapEntryBuilder<'a> {
5037     inner: SpecializationMapEntry,
5038     marker: ::std::marker::PhantomData<&'a ()>,
5039 }
5040 impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> {
5041     type Target = SpecializationMapEntry;
deref(&self) -> &Self::Target5042     fn deref(&self) -> &Self::Target {
5043         &self.inner
5044     }
5045 }
5046 impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5047     fn deref_mut(&mut self) -> &mut Self::Target {
5048         &mut self.inner
5049     }
5050 }
5051 impl<'a> SpecializationMapEntryBuilder<'a> {
constant_id(mut self, constant_id: u32) -> SpecializationMapEntryBuilder<'a>5052     pub fn constant_id(mut self, constant_id: u32) -> SpecializationMapEntryBuilder<'a> {
5053         self.inner.constant_id = constant_id;
5054         self
5055     }
offset(mut self, offset: u32) -> SpecializationMapEntryBuilder<'a>5056     pub fn offset(mut self, offset: u32) -> SpecializationMapEntryBuilder<'a> {
5057         self.inner.offset = offset;
5058         self
5059     }
size(mut self, size: usize) -> SpecializationMapEntryBuilder<'a>5060     pub fn size(mut self, size: usize) -> SpecializationMapEntryBuilder<'a> {
5061         self.inner.size = size;
5062         self
5063     }
5064     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5065     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5066     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SpecializationMapEntry5067     pub fn build(self) -> SpecializationMapEntry {
5068         self.inner
5069     }
5070 }
5071 #[repr(C)]
5072 #[derive(Copy, Clone, Debug)]
5073 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSpecializationInfo.html>"]
5074 pub struct SpecializationInfo {
5075     pub map_entry_count: u32,
5076     pub p_map_entries: *const SpecializationMapEntry,
5077     pub data_size: usize,
5078     pub p_data: *const c_void,
5079 }
5080 impl ::std::default::Default for SpecializationInfo {
default() -> SpecializationInfo5081     fn default() -> SpecializationInfo {
5082         SpecializationInfo {
5083             map_entry_count: u32::default(),
5084             p_map_entries: ::std::ptr::null(),
5085             data_size: usize::default(),
5086             p_data: ::std::ptr::null(),
5087         }
5088     }
5089 }
5090 impl SpecializationInfo {
builder<'a>() -> SpecializationInfoBuilder<'a>5091     pub fn builder<'a>() -> SpecializationInfoBuilder<'a> {
5092         SpecializationInfoBuilder {
5093             inner: SpecializationInfo::default(),
5094             marker: ::std::marker::PhantomData,
5095         }
5096     }
5097 }
5098 #[repr(transparent)]
5099 pub struct SpecializationInfoBuilder<'a> {
5100     inner: SpecializationInfo,
5101     marker: ::std::marker::PhantomData<&'a ()>,
5102 }
5103 impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> {
5104     type Target = SpecializationInfo;
deref(&self) -> &Self::Target5105     fn deref(&self) -> &Self::Target {
5106         &self.inner
5107     }
5108 }
5109 impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5110     fn deref_mut(&mut self) -> &mut Self::Target {
5111         &mut self.inner
5112     }
5113 }
5114 impl<'a> SpecializationInfoBuilder<'a> {
map_entries( mut self, map_entries: &'a [SpecializationMapEntry], ) -> SpecializationInfoBuilder<'a>5115     pub fn map_entries(
5116         mut self,
5117         map_entries: &'a [SpecializationMapEntry],
5118     ) -> SpecializationInfoBuilder<'a> {
5119         self.inner.map_entry_count = map_entries.len() as _;
5120         self.inner.p_map_entries = map_entries.as_ptr();
5121         self
5122     }
data(mut self, data: &'a [u8]) -> SpecializationInfoBuilder<'a>5123     pub fn data(mut self, data: &'a [u8]) -> SpecializationInfoBuilder<'a> {
5124         self.inner.data_size = data.len() as _;
5125         self.inner.p_data = data.as_ptr() as *const c_void;
5126         self
5127     }
5128     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5129     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5130     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SpecializationInfo5131     pub fn build(self) -> SpecializationInfo {
5132         self.inner
5133     }
5134 }
5135 #[repr(C)]
5136 #[derive(Copy, Clone, Debug)]
5137 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateInfo.html>"]
5138 pub struct PipelineShaderStageCreateInfo {
5139     pub s_type: StructureType,
5140     pub p_next: *const c_void,
5141     pub flags: PipelineShaderStageCreateFlags,
5142     pub stage: ShaderStageFlags,
5143     pub module: ShaderModule,
5144     pub p_name: *const c_char,
5145     pub p_specialization_info: *const SpecializationInfo,
5146 }
5147 impl ::std::default::Default for PipelineShaderStageCreateInfo {
default() -> PipelineShaderStageCreateInfo5148     fn default() -> PipelineShaderStageCreateInfo {
5149         PipelineShaderStageCreateInfo {
5150             s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
5151             p_next: ::std::ptr::null(),
5152             flags: PipelineShaderStageCreateFlags::default(),
5153             stage: ShaderStageFlags::default(),
5154             module: ShaderModule::default(),
5155             p_name: ::std::ptr::null(),
5156             p_specialization_info: ::std::ptr::null(),
5157         }
5158     }
5159 }
5160 impl PipelineShaderStageCreateInfo {
builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a>5161     pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> {
5162         PipelineShaderStageCreateInfoBuilder {
5163             inner: PipelineShaderStageCreateInfo::default(),
5164             marker: ::std::marker::PhantomData,
5165         }
5166     }
5167 }
5168 #[repr(transparent)]
5169 pub struct PipelineShaderStageCreateInfoBuilder<'a> {
5170     inner: PipelineShaderStageCreateInfo,
5171     marker: ::std::marker::PhantomData<&'a ()>,
5172 }
5173 pub unsafe trait ExtendsPipelineShaderStageCreateInfo {}
5174 impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> {
5175     type Target = PipelineShaderStageCreateInfo;
deref(&self) -> &Self::Target5176     fn deref(&self) -> &Self::Target {
5177         &self.inner
5178     }
5179 }
5180 impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5181     fn deref_mut(&mut self) -> &mut Self::Target {
5182         &mut self.inner
5183     }
5184 }
5185 impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineShaderStageCreateFlags, ) -> PipelineShaderStageCreateInfoBuilder<'a>5186     pub fn flags(
5187         mut self,
5188         flags: PipelineShaderStageCreateFlags,
5189     ) -> PipelineShaderStageCreateInfoBuilder<'a> {
5190         self.inner.flags = flags;
5191         self
5192     }
stage(mut self, stage: ShaderStageFlags) -> PipelineShaderStageCreateInfoBuilder<'a>5193     pub fn stage(mut self, stage: ShaderStageFlags) -> PipelineShaderStageCreateInfoBuilder<'a> {
5194         self.inner.stage = stage;
5195         self
5196     }
module(mut self, module: ShaderModule) -> PipelineShaderStageCreateInfoBuilder<'a>5197     pub fn module(mut self, module: ShaderModule) -> PipelineShaderStageCreateInfoBuilder<'a> {
5198         self.inner.module = module;
5199         self
5200     }
name(mut self, name: &'a ::std::ffi::CStr) -> PipelineShaderStageCreateInfoBuilder<'a>5201     pub fn name(mut self, name: &'a ::std::ffi::CStr) -> PipelineShaderStageCreateInfoBuilder<'a> {
5202         self.inner.p_name = name.as_ptr();
5203         self
5204     }
specialization_info( mut self, specialization_info: &'a SpecializationInfo, ) -> PipelineShaderStageCreateInfoBuilder<'a>5205     pub fn specialization_info(
5206         mut self,
5207         specialization_info: &'a SpecializationInfo,
5208     ) -> PipelineShaderStageCreateInfoBuilder<'a> {
5209         self.inner.p_specialization_info = specialization_info;
5210         self
5211     }
5212     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5213     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5214     #[doc = r" valid extension structs can be pushed into the chain."]
5215     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5216     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineShaderStageCreateInfo>( mut self, next: &'a mut T, ) -> PipelineShaderStageCreateInfoBuilder<'a>5217     pub fn push_next<T: ExtendsPipelineShaderStageCreateInfo>(
5218         mut self,
5219         next: &'a mut T,
5220     ) -> PipelineShaderStageCreateInfoBuilder<'a> {
5221         unsafe {
5222             let next_ptr = next as *mut T as *mut BaseOutStructure;
5223             let last_next = ptr_chain_iter(next).last().unwrap();
5224             (*last_next).p_next = self.inner.p_next as _;
5225             self.inner.p_next = next_ptr as _;
5226         }
5227         self
5228     }
5229     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5230     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5231     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineShaderStageCreateInfo5232     pub fn build(self) -> PipelineShaderStageCreateInfo {
5233         self.inner
5234     }
5235 }
5236 #[repr(C)]
5237 #[derive(Copy, Clone, Debug)]
5238 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComputePipelineCreateInfo.html>"]
5239 pub struct ComputePipelineCreateInfo {
5240     pub s_type: StructureType,
5241     pub p_next: *const c_void,
5242     pub flags: PipelineCreateFlags,
5243     pub stage: PipelineShaderStageCreateInfo,
5244     pub layout: PipelineLayout,
5245     pub base_pipeline_handle: Pipeline,
5246     pub base_pipeline_index: i32,
5247 }
5248 impl ::std::default::Default for ComputePipelineCreateInfo {
default() -> ComputePipelineCreateInfo5249     fn default() -> ComputePipelineCreateInfo {
5250         ComputePipelineCreateInfo {
5251             s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO,
5252             p_next: ::std::ptr::null(),
5253             flags: PipelineCreateFlags::default(),
5254             stage: PipelineShaderStageCreateInfo::default(),
5255             layout: PipelineLayout::default(),
5256             base_pipeline_handle: Pipeline::default(),
5257             base_pipeline_index: i32::default(),
5258         }
5259     }
5260 }
5261 impl ComputePipelineCreateInfo {
builder<'a>() -> ComputePipelineCreateInfoBuilder<'a>5262     pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> {
5263         ComputePipelineCreateInfoBuilder {
5264             inner: ComputePipelineCreateInfo::default(),
5265             marker: ::std::marker::PhantomData,
5266         }
5267     }
5268 }
5269 #[repr(transparent)]
5270 pub struct ComputePipelineCreateInfoBuilder<'a> {
5271     inner: ComputePipelineCreateInfo,
5272     marker: ::std::marker::PhantomData<&'a ()>,
5273 }
5274 pub unsafe trait ExtendsComputePipelineCreateInfo {}
5275 impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> {
5276     type Target = ComputePipelineCreateInfo;
deref(&self) -> &Self::Target5277     fn deref(&self) -> &Self::Target {
5278         &self.inner
5279     }
5280 }
5281 impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5282     fn deref_mut(&mut self) -> &mut Self::Target {
5283         &mut self.inner
5284     }
5285 }
5286 impl<'a> ComputePipelineCreateInfoBuilder<'a> {
flags(mut self, flags: PipelineCreateFlags) -> ComputePipelineCreateInfoBuilder<'a>5287     pub fn flags(mut self, flags: PipelineCreateFlags) -> ComputePipelineCreateInfoBuilder<'a> {
5288         self.inner.flags = flags;
5289         self
5290     }
stage( mut self, stage: PipelineShaderStageCreateInfo, ) -> ComputePipelineCreateInfoBuilder<'a>5291     pub fn stage(
5292         mut self,
5293         stage: PipelineShaderStageCreateInfo,
5294     ) -> ComputePipelineCreateInfoBuilder<'a> {
5295         self.inner.stage = stage;
5296         self
5297     }
layout(mut self, layout: PipelineLayout) -> ComputePipelineCreateInfoBuilder<'a>5298     pub fn layout(mut self, layout: PipelineLayout) -> ComputePipelineCreateInfoBuilder<'a> {
5299         self.inner.layout = layout;
5300         self
5301     }
base_pipeline_handle( mut self, base_pipeline_handle: Pipeline, ) -> ComputePipelineCreateInfoBuilder<'a>5302     pub fn base_pipeline_handle(
5303         mut self,
5304         base_pipeline_handle: Pipeline,
5305     ) -> ComputePipelineCreateInfoBuilder<'a> {
5306         self.inner.base_pipeline_handle = base_pipeline_handle;
5307         self
5308     }
base_pipeline_index( mut self, base_pipeline_index: i32, ) -> ComputePipelineCreateInfoBuilder<'a>5309     pub fn base_pipeline_index(
5310         mut self,
5311         base_pipeline_index: i32,
5312     ) -> ComputePipelineCreateInfoBuilder<'a> {
5313         self.inner.base_pipeline_index = base_pipeline_index;
5314         self
5315     }
5316     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5317     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5318     #[doc = r" valid extension structs can be pushed into the chain."]
5319     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5320     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsComputePipelineCreateInfo>( mut self, next: &'a mut T, ) -> ComputePipelineCreateInfoBuilder<'a>5321     pub fn push_next<T: ExtendsComputePipelineCreateInfo>(
5322         mut self,
5323         next: &'a mut T,
5324     ) -> ComputePipelineCreateInfoBuilder<'a> {
5325         unsafe {
5326             let next_ptr = next as *mut T as *mut BaseOutStructure;
5327             let last_next = ptr_chain_iter(next).last().unwrap();
5328             (*last_next).p_next = self.inner.p_next as _;
5329             self.inner.p_next = next_ptr as _;
5330         }
5331         self
5332     }
5333     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5334     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5335     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ComputePipelineCreateInfo5336     pub fn build(self) -> ComputePipelineCreateInfo {
5337         self.inner
5338     }
5339 }
5340 #[repr(C)]
5341 #[derive(Copy, Clone, Default, Debug)]
5342 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDescription.html>"]
5343 pub struct VertexInputBindingDescription {
5344     pub binding: u32,
5345     pub stride: u32,
5346     pub input_rate: VertexInputRate,
5347 }
5348 impl VertexInputBindingDescription {
builder<'a>() -> VertexInputBindingDescriptionBuilder<'a>5349     pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> {
5350         VertexInputBindingDescriptionBuilder {
5351             inner: VertexInputBindingDescription::default(),
5352             marker: ::std::marker::PhantomData,
5353         }
5354     }
5355 }
5356 #[repr(transparent)]
5357 pub struct VertexInputBindingDescriptionBuilder<'a> {
5358     inner: VertexInputBindingDescription,
5359     marker: ::std::marker::PhantomData<&'a ()>,
5360 }
5361 impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> {
5362     type Target = VertexInputBindingDescription;
deref(&self) -> &Self::Target5363     fn deref(&self) -> &Self::Target {
5364         &self.inner
5365     }
5366 }
5367 impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5368     fn deref_mut(&mut self) -> &mut Self::Target {
5369         &mut self.inner
5370     }
5371 }
5372 impl<'a> VertexInputBindingDescriptionBuilder<'a> {
binding(mut self, binding: u32) -> VertexInputBindingDescriptionBuilder<'a>5373     pub fn binding(mut self, binding: u32) -> VertexInputBindingDescriptionBuilder<'a> {
5374         self.inner.binding = binding;
5375         self
5376     }
stride(mut self, stride: u32) -> VertexInputBindingDescriptionBuilder<'a>5377     pub fn stride(mut self, stride: u32) -> VertexInputBindingDescriptionBuilder<'a> {
5378         self.inner.stride = stride;
5379         self
5380     }
input_rate( mut self, input_rate: VertexInputRate, ) -> VertexInputBindingDescriptionBuilder<'a>5381     pub fn input_rate(
5382         mut self,
5383         input_rate: VertexInputRate,
5384     ) -> VertexInputBindingDescriptionBuilder<'a> {
5385         self.inner.input_rate = input_rate;
5386         self
5387     }
5388     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5389     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5390     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputBindingDescription5391     pub fn build(self) -> VertexInputBindingDescription {
5392         self.inner
5393     }
5394 }
5395 #[repr(C)]
5396 #[derive(Copy, Clone, Default, Debug)]
5397 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputAttributeDescription.html>"]
5398 pub struct VertexInputAttributeDescription {
5399     pub location: u32,
5400     pub binding: u32,
5401     pub format: Format,
5402     pub offset: u32,
5403 }
5404 impl VertexInputAttributeDescription {
builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a>5405     pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> {
5406         VertexInputAttributeDescriptionBuilder {
5407             inner: VertexInputAttributeDescription::default(),
5408             marker: ::std::marker::PhantomData,
5409         }
5410     }
5411 }
5412 #[repr(transparent)]
5413 pub struct VertexInputAttributeDescriptionBuilder<'a> {
5414     inner: VertexInputAttributeDescription,
5415     marker: ::std::marker::PhantomData<&'a ()>,
5416 }
5417 impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> {
5418     type Target = VertexInputAttributeDescription;
deref(&self) -> &Self::Target5419     fn deref(&self) -> &Self::Target {
5420         &self.inner
5421     }
5422 }
5423 impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5424     fn deref_mut(&mut self) -> &mut Self::Target {
5425         &mut self.inner
5426     }
5427 }
5428 impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
location(mut self, location: u32) -> VertexInputAttributeDescriptionBuilder<'a>5429     pub fn location(mut self, location: u32) -> VertexInputAttributeDescriptionBuilder<'a> {
5430         self.inner.location = location;
5431         self
5432     }
binding(mut self, binding: u32) -> VertexInputAttributeDescriptionBuilder<'a>5433     pub fn binding(mut self, binding: u32) -> VertexInputAttributeDescriptionBuilder<'a> {
5434         self.inner.binding = binding;
5435         self
5436     }
format(mut self, format: Format) -> VertexInputAttributeDescriptionBuilder<'a>5437     pub fn format(mut self, format: Format) -> VertexInputAttributeDescriptionBuilder<'a> {
5438         self.inner.format = format;
5439         self
5440     }
offset(mut self, offset: u32) -> VertexInputAttributeDescriptionBuilder<'a>5441     pub fn offset(mut self, offset: u32) -> VertexInputAttributeDescriptionBuilder<'a> {
5442         self.inner.offset = offset;
5443         self
5444     }
5445     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5446     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5447     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputAttributeDescription5448     pub fn build(self) -> VertexInputAttributeDescription {
5449         self.inner
5450     }
5451 }
5452 #[repr(C)]
5453 #[derive(Copy, Clone, Debug)]
5454 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html>"]
5455 pub struct PipelineVertexInputStateCreateInfo {
5456     pub s_type: StructureType,
5457     pub p_next: *const c_void,
5458     pub flags: PipelineVertexInputStateCreateFlags,
5459     pub vertex_binding_description_count: u32,
5460     pub p_vertex_binding_descriptions: *const VertexInputBindingDescription,
5461     pub vertex_attribute_description_count: u32,
5462     pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription,
5463 }
5464 impl ::std::default::Default for PipelineVertexInputStateCreateInfo {
default() -> PipelineVertexInputStateCreateInfo5465     fn default() -> PipelineVertexInputStateCreateInfo {
5466         PipelineVertexInputStateCreateInfo {
5467             s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
5468             p_next: ::std::ptr::null(),
5469             flags: PipelineVertexInputStateCreateFlags::default(),
5470             vertex_binding_description_count: u32::default(),
5471             p_vertex_binding_descriptions: ::std::ptr::null(),
5472             vertex_attribute_description_count: u32::default(),
5473             p_vertex_attribute_descriptions: ::std::ptr::null(),
5474         }
5475     }
5476 }
5477 impl PipelineVertexInputStateCreateInfo {
builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a>5478     pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5479         PipelineVertexInputStateCreateInfoBuilder {
5480             inner: PipelineVertexInputStateCreateInfo::default(),
5481             marker: ::std::marker::PhantomData,
5482         }
5483     }
5484 }
5485 #[repr(transparent)]
5486 pub struct PipelineVertexInputStateCreateInfoBuilder<'a> {
5487     inner: PipelineVertexInputStateCreateInfo,
5488     marker: ::std::marker::PhantomData<&'a ()>,
5489 }
5490 pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {}
5491 impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
5492     type Target = PipelineVertexInputStateCreateInfo;
deref(&self) -> &Self::Target5493     fn deref(&self) -> &Self::Target {
5494         &self.inner
5495     }
5496 }
5497 impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5498     fn deref_mut(&mut self) -> &mut Self::Target {
5499         &mut self.inner
5500     }
5501 }
5502 impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineVertexInputStateCreateFlags, ) -> PipelineVertexInputStateCreateInfoBuilder<'a>5503     pub fn flags(
5504         mut self,
5505         flags: PipelineVertexInputStateCreateFlags,
5506     ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5507         self.inner.flags = flags;
5508         self
5509     }
vertex_binding_descriptions( mut self, vertex_binding_descriptions: &'a [VertexInputBindingDescription], ) -> PipelineVertexInputStateCreateInfoBuilder<'a>5510     pub fn vertex_binding_descriptions(
5511         mut self,
5512         vertex_binding_descriptions: &'a [VertexInputBindingDescription],
5513     ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5514         self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _;
5515         self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr();
5516         self
5517     }
vertex_attribute_descriptions( mut self, vertex_attribute_descriptions: &'a [VertexInputAttributeDescription], ) -> PipelineVertexInputStateCreateInfoBuilder<'a>5518     pub fn vertex_attribute_descriptions(
5519         mut self,
5520         vertex_attribute_descriptions: &'a [VertexInputAttributeDescription],
5521     ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5522         self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _;
5523         self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr();
5524         self
5525     }
5526     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5527     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5528     #[doc = r" valid extension structs can be pushed into the chain."]
5529     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5530     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineVertexInputStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineVertexInputStateCreateInfoBuilder<'a>5531     pub fn push_next<T: ExtendsPipelineVertexInputStateCreateInfo>(
5532         mut self,
5533         next: &'a mut T,
5534     ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
5535         unsafe {
5536             let next_ptr = next as *mut T as *mut BaseOutStructure;
5537             let last_next = ptr_chain_iter(next).last().unwrap();
5538             (*last_next).p_next = self.inner.p_next as _;
5539             self.inner.p_next = next_ptr as _;
5540         }
5541         self
5542     }
5543     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5544     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5545     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineVertexInputStateCreateInfo5546     pub fn build(self) -> PipelineVertexInputStateCreateInfo {
5547         self.inner
5548     }
5549 }
5550 #[repr(C)]
5551 #[derive(Copy, Clone, Debug)]
5552 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html>"]
5553 pub struct PipelineInputAssemblyStateCreateInfo {
5554     pub s_type: StructureType,
5555     pub p_next: *const c_void,
5556     pub flags: PipelineInputAssemblyStateCreateFlags,
5557     pub topology: PrimitiveTopology,
5558     pub primitive_restart_enable: Bool32,
5559 }
5560 impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo {
default() -> PipelineInputAssemblyStateCreateInfo5561     fn default() -> PipelineInputAssemblyStateCreateInfo {
5562         PipelineInputAssemblyStateCreateInfo {
5563             s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
5564             p_next: ::std::ptr::null(),
5565             flags: PipelineInputAssemblyStateCreateFlags::default(),
5566             topology: PrimitiveTopology::default(),
5567             primitive_restart_enable: Bool32::default(),
5568         }
5569     }
5570 }
5571 impl PipelineInputAssemblyStateCreateInfo {
builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a>5572     pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5573         PipelineInputAssemblyStateCreateInfoBuilder {
5574             inner: PipelineInputAssemblyStateCreateInfo::default(),
5575             marker: ::std::marker::PhantomData,
5576         }
5577     }
5578 }
5579 #[repr(transparent)]
5580 pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5581     inner: PipelineInputAssemblyStateCreateInfo,
5582     marker: ::std::marker::PhantomData<&'a ()>,
5583 }
5584 pub unsafe trait ExtendsPipelineInputAssemblyStateCreateInfo {}
5585 impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5586     type Target = PipelineInputAssemblyStateCreateInfo;
deref(&self) -> &Self::Target5587     fn deref(&self) -> &Self::Target {
5588         &self.inner
5589     }
5590 }
5591 impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5592     fn deref_mut(&mut self) -> &mut Self::Target {
5593         &mut self.inner
5594     }
5595 }
5596 impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineInputAssemblyStateCreateFlags, ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a>5597     pub fn flags(
5598         mut self,
5599         flags: PipelineInputAssemblyStateCreateFlags,
5600     ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5601         self.inner.flags = flags;
5602         self
5603     }
topology( mut self, topology: PrimitiveTopology, ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a>5604     pub fn topology(
5605         mut self,
5606         topology: PrimitiveTopology,
5607     ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5608         self.inner.topology = topology;
5609         self
5610     }
primitive_restart_enable( mut self, primitive_restart_enable: bool, ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a>5611     pub fn primitive_restart_enable(
5612         mut self,
5613         primitive_restart_enable: bool,
5614     ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5615         self.inner.primitive_restart_enable = primitive_restart_enable.into();
5616         self
5617     }
5618     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5619     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5620     #[doc = r" valid extension structs can be pushed into the chain."]
5621     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5622     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineInputAssemblyStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a>5623     pub fn push_next<T: ExtendsPipelineInputAssemblyStateCreateInfo>(
5624         mut self,
5625         next: &'a mut T,
5626     ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
5627         unsafe {
5628             let next_ptr = next as *mut T as *mut BaseOutStructure;
5629             let last_next = ptr_chain_iter(next).last().unwrap();
5630             (*last_next).p_next = self.inner.p_next as _;
5631             self.inner.p_next = next_ptr as _;
5632         }
5633         self
5634     }
5635     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5636     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5637     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineInputAssemblyStateCreateInfo5638     pub fn build(self) -> PipelineInputAssemblyStateCreateInfo {
5639         self.inner
5640     }
5641 }
5642 #[repr(C)]
5643 #[derive(Copy, Clone, Debug)]
5644 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateInfo.html>"]
5645 pub struct PipelineTessellationStateCreateInfo {
5646     pub s_type: StructureType,
5647     pub p_next: *const c_void,
5648     pub flags: PipelineTessellationStateCreateFlags,
5649     pub patch_control_points: u32,
5650 }
5651 impl ::std::default::Default for PipelineTessellationStateCreateInfo {
default() -> PipelineTessellationStateCreateInfo5652     fn default() -> PipelineTessellationStateCreateInfo {
5653         PipelineTessellationStateCreateInfo {
5654             s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO,
5655             p_next: ::std::ptr::null(),
5656             flags: PipelineTessellationStateCreateFlags::default(),
5657             patch_control_points: u32::default(),
5658         }
5659     }
5660 }
5661 impl PipelineTessellationStateCreateInfo {
builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a>5662     pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> {
5663         PipelineTessellationStateCreateInfoBuilder {
5664             inner: PipelineTessellationStateCreateInfo::default(),
5665             marker: ::std::marker::PhantomData,
5666         }
5667     }
5668 }
5669 #[repr(transparent)]
5670 pub struct PipelineTessellationStateCreateInfoBuilder<'a> {
5671     inner: PipelineTessellationStateCreateInfo,
5672     marker: ::std::marker::PhantomData<&'a ()>,
5673 }
5674 pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {}
5675 impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
5676     type Target = PipelineTessellationStateCreateInfo;
deref(&self) -> &Self::Target5677     fn deref(&self) -> &Self::Target {
5678         &self.inner
5679     }
5680 }
5681 impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5682     fn deref_mut(&mut self) -> &mut Self::Target {
5683         &mut self.inner
5684     }
5685 }
5686 impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineTessellationStateCreateFlags, ) -> PipelineTessellationStateCreateInfoBuilder<'a>5687     pub fn flags(
5688         mut self,
5689         flags: PipelineTessellationStateCreateFlags,
5690     ) -> PipelineTessellationStateCreateInfoBuilder<'a> {
5691         self.inner.flags = flags;
5692         self
5693     }
patch_control_points( mut self, patch_control_points: u32, ) -> PipelineTessellationStateCreateInfoBuilder<'a>5694     pub fn patch_control_points(
5695         mut self,
5696         patch_control_points: u32,
5697     ) -> PipelineTessellationStateCreateInfoBuilder<'a> {
5698         self.inner.patch_control_points = patch_control_points;
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`."]
push_next<T: ExtendsPipelineTessellationStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineTessellationStateCreateInfoBuilder<'a>5706     pub fn push_next<T: ExtendsPipelineTessellationStateCreateInfo>(
5707         mut self,
5708         next: &'a mut T,
5709     ) -> PipelineTessellationStateCreateInfoBuilder<'a> {
5710         unsafe {
5711             let next_ptr = next as *mut T as *mut BaseOutStructure;
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 as _;
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."]
build(self) -> PipelineTessellationStateCreateInfo5721     pub fn build(self) -> PipelineTessellationStateCreateInfo {
5722         self.inner
5723     }
5724 }
5725 #[repr(C)]
5726 #[derive(Copy, Clone, Debug)]
5727 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateInfo.html>"]
5728 pub struct PipelineViewportStateCreateInfo {
5729     pub s_type: StructureType,
5730     pub p_next: *const c_void,
5731     pub flags: PipelineViewportStateCreateFlags,
5732     pub viewport_count: u32,
5733     pub p_viewports: *const Viewport,
5734     pub scissor_count: u32,
5735     pub p_scissors: *const Rect2D,
5736 }
5737 impl ::std::default::Default for PipelineViewportStateCreateInfo {
default() -> PipelineViewportStateCreateInfo5738     fn default() -> PipelineViewportStateCreateInfo {
5739         PipelineViewportStateCreateInfo {
5740             s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO,
5741             p_next: ::std::ptr::null(),
5742             flags: PipelineViewportStateCreateFlags::default(),
5743             viewport_count: u32::default(),
5744             p_viewports: ::std::ptr::null(),
5745             scissor_count: u32::default(),
5746             p_scissors: ::std::ptr::null(),
5747         }
5748     }
5749 }
5750 impl PipelineViewportStateCreateInfo {
builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a>5751     pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> {
5752         PipelineViewportStateCreateInfoBuilder {
5753             inner: PipelineViewportStateCreateInfo::default(),
5754             marker: ::std::marker::PhantomData,
5755         }
5756     }
5757 }
5758 #[repr(transparent)]
5759 pub struct PipelineViewportStateCreateInfoBuilder<'a> {
5760     inner: PipelineViewportStateCreateInfo,
5761     marker: ::std::marker::PhantomData<&'a ()>,
5762 }
5763 pub unsafe trait ExtendsPipelineViewportStateCreateInfo {}
5764 impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> {
5765     type Target = PipelineViewportStateCreateInfo;
deref(&self) -> &Self::Target5766     fn deref(&self) -> &Self::Target {
5767         &self.inner
5768     }
5769 }
5770 impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5771     fn deref_mut(&mut self) -> &mut Self::Target {
5772         &mut self.inner
5773     }
5774 }
5775 impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineViewportStateCreateFlags, ) -> PipelineViewportStateCreateInfoBuilder<'a>5776     pub fn flags(
5777         mut self,
5778         flags: PipelineViewportStateCreateFlags,
5779     ) -> PipelineViewportStateCreateInfoBuilder<'a> {
5780         self.inner.flags = flags;
5781         self
5782     }
viewport_count( mut self, viewport_count: u32, ) -> PipelineViewportStateCreateInfoBuilder<'a>5783     pub fn viewport_count(
5784         mut self,
5785         viewport_count: u32,
5786     ) -> PipelineViewportStateCreateInfoBuilder<'a> {
5787         self.inner.viewport_count = viewport_count;
5788         self
5789     }
viewports( mut self, viewports: &'a [Viewport], ) -> PipelineViewportStateCreateInfoBuilder<'a>5790     pub fn viewports(
5791         mut self,
5792         viewports: &'a [Viewport],
5793     ) -> PipelineViewportStateCreateInfoBuilder<'a> {
5794         self.inner.viewport_count = viewports.len() as _;
5795         self.inner.p_viewports = viewports.as_ptr();
5796         self
5797     }
scissor_count( mut self, scissor_count: u32, ) -> PipelineViewportStateCreateInfoBuilder<'a>5798     pub fn scissor_count(
5799         mut self,
5800         scissor_count: u32,
5801     ) -> PipelineViewportStateCreateInfoBuilder<'a> {
5802         self.inner.scissor_count = scissor_count;
5803         self
5804     }
scissors( mut self, scissors: &'a [Rect2D], ) -> PipelineViewportStateCreateInfoBuilder<'a>5805     pub fn scissors(
5806         mut self,
5807         scissors: &'a [Rect2D],
5808     ) -> PipelineViewportStateCreateInfoBuilder<'a> {
5809         self.inner.scissor_count = scissors.len() as _;
5810         self.inner.p_scissors = scissors.as_ptr();
5811         self
5812     }
5813     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5814     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5815     #[doc = r" valid extension structs can be pushed into the chain."]
5816     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5817     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineViewportStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineViewportStateCreateInfoBuilder<'a>5818     pub fn push_next<T: ExtendsPipelineViewportStateCreateInfo>(
5819         mut self,
5820         next: &'a mut T,
5821     ) -> PipelineViewportStateCreateInfoBuilder<'a> {
5822         unsafe {
5823             let next_ptr = next as *mut T as *mut BaseOutStructure;
5824             let last_next = ptr_chain_iter(next).last().unwrap();
5825             (*last_next).p_next = self.inner.p_next as _;
5826             self.inner.p_next = next_ptr as _;
5827         }
5828         self
5829     }
5830     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5831     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5832     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportStateCreateInfo5833     pub fn build(self) -> PipelineViewportStateCreateInfo {
5834         self.inner
5835     }
5836 }
5837 #[repr(C)]
5838 #[derive(Copy, Clone, Debug)]
5839 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html>"]
5840 pub struct PipelineRasterizationStateCreateInfo {
5841     pub s_type: StructureType,
5842     pub p_next: *const c_void,
5843     pub flags: PipelineRasterizationStateCreateFlags,
5844     pub depth_clamp_enable: Bool32,
5845     pub rasterizer_discard_enable: Bool32,
5846     pub polygon_mode: PolygonMode,
5847     pub cull_mode: CullModeFlags,
5848     pub front_face: FrontFace,
5849     pub depth_bias_enable: Bool32,
5850     pub depth_bias_constant_factor: f32,
5851     pub depth_bias_clamp: f32,
5852     pub depth_bias_slope_factor: f32,
5853     pub line_width: f32,
5854 }
5855 impl ::std::default::Default for PipelineRasterizationStateCreateInfo {
default() -> PipelineRasterizationStateCreateInfo5856     fn default() -> PipelineRasterizationStateCreateInfo {
5857         PipelineRasterizationStateCreateInfo {
5858             s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
5859             p_next: ::std::ptr::null(),
5860             flags: PipelineRasterizationStateCreateFlags::default(),
5861             depth_clamp_enable: Bool32::default(),
5862             rasterizer_discard_enable: Bool32::default(),
5863             polygon_mode: PolygonMode::default(),
5864             cull_mode: CullModeFlags::default(),
5865             front_face: FrontFace::default(),
5866             depth_bias_enable: Bool32::default(),
5867             depth_bias_constant_factor: f32::default(),
5868             depth_bias_clamp: f32::default(),
5869             depth_bias_slope_factor: f32::default(),
5870             line_width: f32::default(),
5871         }
5872     }
5873 }
5874 impl PipelineRasterizationStateCreateInfo {
builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a>5875     pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5876         PipelineRasterizationStateCreateInfoBuilder {
5877             inner: PipelineRasterizationStateCreateInfo::default(),
5878             marker: ::std::marker::PhantomData,
5879         }
5880     }
5881 }
5882 #[repr(transparent)]
5883 pub struct PipelineRasterizationStateCreateInfoBuilder<'a> {
5884     inner: PipelineRasterizationStateCreateInfo,
5885     marker: ::std::marker::PhantomData<&'a ()>,
5886 }
5887 pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {}
5888 impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
5889     type Target = PipelineRasterizationStateCreateInfo;
deref(&self) -> &Self::Target5890     fn deref(&self) -> &Self::Target {
5891         &self.inner
5892     }
5893 }
5894 impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target5895     fn deref_mut(&mut self) -> &mut Self::Target {
5896         &mut self.inner
5897     }
5898 }
5899 impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineRasterizationStateCreateFlags, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5900     pub fn flags(
5901         mut self,
5902         flags: PipelineRasterizationStateCreateFlags,
5903     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5904         self.inner.flags = flags;
5905         self
5906     }
depth_clamp_enable( mut self, depth_clamp_enable: bool, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5907     pub fn depth_clamp_enable(
5908         mut self,
5909         depth_clamp_enable: bool,
5910     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5911         self.inner.depth_clamp_enable = depth_clamp_enable.into();
5912         self
5913     }
rasterizer_discard_enable( mut self, rasterizer_discard_enable: bool, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5914     pub fn rasterizer_discard_enable(
5915         mut self,
5916         rasterizer_discard_enable: bool,
5917     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5918         self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into();
5919         self
5920     }
polygon_mode( mut self, polygon_mode: PolygonMode, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5921     pub fn polygon_mode(
5922         mut self,
5923         polygon_mode: PolygonMode,
5924     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5925         self.inner.polygon_mode = polygon_mode;
5926         self
5927     }
cull_mode( mut self, cull_mode: CullModeFlags, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5928     pub fn cull_mode(
5929         mut self,
5930         cull_mode: CullModeFlags,
5931     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5932         self.inner.cull_mode = cull_mode;
5933         self
5934     }
front_face( mut self, front_face: FrontFace, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5935     pub fn front_face(
5936         mut self,
5937         front_face: FrontFace,
5938     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5939         self.inner.front_face = front_face;
5940         self
5941     }
depth_bias_enable( mut self, depth_bias_enable: bool, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5942     pub fn depth_bias_enable(
5943         mut self,
5944         depth_bias_enable: bool,
5945     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5946         self.inner.depth_bias_enable = depth_bias_enable.into();
5947         self
5948     }
depth_bias_constant_factor( mut self, depth_bias_constant_factor: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5949     pub fn depth_bias_constant_factor(
5950         mut self,
5951         depth_bias_constant_factor: f32,
5952     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5953         self.inner.depth_bias_constant_factor = depth_bias_constant_factor;
5954         self
5955     }
depth_bias_clamp( mut self, depth_bias_clamp: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5956     pub fn depth_bias_clamp(
5957         mut self,
5958         depth_bias_clamp: f32,
5959     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5960         self.inner.depth_bias_clamp = depth_bias_clamp;
5961         self
5962     }
depth_bias_slope_factor( mut self, depth_bias_slope_factor: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5963     pub fn depth_bias_slope_factor(
5964         mut self,
5965         depth_bias_slope_factor: f32,
5966     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5967         self.inner.depth_bias_slope_factor = depth_bias_slope_factor;
5968         self
5969     }
line_width( mut self, line_width: f32, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5970     pub fn line_width(
5971         mut self,
5972         line_width: f32,
5973     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5974         self.inner.line_width = line_width;
5975         self
5976     }
5977     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
5978     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
5979     #[doc = r" valid extension structs can be pushed into the chain."]
5980     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
5981     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineRasterizationStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineRasterizationStateCreateInfoBuilder<'a>5982     pub fn push_next<T: ExtendsPipelineRasterizationStateCreateInfo>(
5983         mut self,
5984         next: &'a mut T,
5985     ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
5986         unsafe {
5987             let next_ptr = next as *mut T as *mut BaseOutStructure;
5988             let last_next = ptr_chain_iter(next).last().unwrap();
5989             (*last_next).p_next = self.inner.p_next as _;
5990             self.inner.p_next = next_ptr as _;
5991         }
5992         self
5993     }
5994     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
5995     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
5996     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationStateCreateInfo5997     pub fn build(self) -> PipelineRasterizationStateCreateInfo {
5998         self.inner
5999     }
6000 }
6001 #[repr(C)]
6002 #[derive(Copy, Clone, Debug)]
6003 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html>"]
6004 pub struct PipelineMultisampleStateCreateInfo {
6005     pub s_type: StructureType,
6006     pub p_next: *const c_void,
6007     pub flags: PipelineMultisampleStateCreateFlags,
6008     pub rasterization_samples: SampleCountFlags,
6009     pub sample_shading_enable: Bool32,
6010     pub min_sample_shading: f32,
6011     pub p_sample_mask: *const SampleMask,
6012     pub alpha_to_coverage_enable: Bool32,
6013     pub alpha_to_one_enable: Bool32,
6014 }
6015 impl ::std::default::Default for PipelineMultisampleStateCreateInfo {
default() -> PipelineMultisampleStateCreateInfo6016     fn default() -> PipelineMultisampleStateCreateInfo {
6017         PipelineMultisampleStateCreateInfo {
6018             s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
6019             p_next: ::std::ptr::null(),
6020             flags: PipelineMultisampleStateCreateFlags::default(),
6021             rasterization_samples: SampleCountFlags::default(),
6022             sample_shading_enable: Bool32::default(),
6023             min_sample_shading: f32::default(),
6024             p_sample_mask: ::std::ptr::null(),
6025             alpha_to_coverage_enable: Bool32::default(),
6026             alpha_to_one_enable: Bool32::default(),
6027         }
6028     }
6029 }
6030 impl PipelineMultisampleStateCreateInfo {
builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a>6031     pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6032         PipelineMultisampleStateCreateInfoBuilder {
6033             inner: PipelineMultisampleStateCreateInfo::default(),
6034             marker: ::std::marker::PhantomData,
6035         }
6036     }
6037 }
6038 #[repr(transparent)]
6039 pub struct PipelineMultisampleStateCreateInfoBuilder<'a> {
6040     inner: PipelineMultisampleStateCreateInfo,
6041     marker: ::std::marker::PhantomData<&'a ()>,
6042 }
6043 pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {}
6044 impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
6045     type Target = PipelineMultisampleStateCreateInfo;
deref(&self) -> &Self::Target6046     fn deref(&self) -> &Self::Target {
6047         &self.inner
6048     }
6049 }
6050 impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6051     fn deref_mut(&mut self) -> &mut Self::Target {
6052         &mut self.inner
6053     }
6054 }
6055 impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineMultisampleStateCreateFlags, ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6056     pub fn flags(
6057         mut self,
6058         flags: PipelineMultisampleStateCreateFlags,
6059     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6060         self.inner.flags = flags;
6061         self
6062     }
rasterization_samples( mut self, rasterization_samples: SampleCountFlags, ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6063     pub fn rasterization_samples(
6064         mut self,
6065         rasterization_samples: SampleCountFlags,
6066     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6067         self.inner.rasterization_samples = rasterization_samples;
6068         self
6069     }
sample_shading_enable( mut self, sample_shading_enable: bool, ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6070     pub fn sample_shading_enable(
6071         mut self,
6072         sample_shading_enable: bool,
6073     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6074         self.inner.sample_shading_enable = sample_shading_enable.into();
6075         self
6076     }
min_sample_shading( mut self, min_sample_shading: f32, ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6077     pub fn min_sample_shading(
6078         mut self,
6079         min_sample_shading: f32,
6080     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6081         self.inner.min_sample_shading = min_sample_shading;
6082         self
6083     }
sample_mask( mut self, sample_mask: &'a [SampleMask], ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6084     pub fn sample_mask(
6085         mut self,
6086         sample_mask: &'a [SampleMask],
6087     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6088         self.inner.p_sample_mask = sample_mask.as_ptr() as *const SampleMask;
6089         self
6090     }
alpha_to_coverage_enable( mut self, alpha_to_coverage_enable: bool, ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6091     pub fn alpha_to_coverage_enable(
6092         mut self,
6093         alpha_to_coverage_enable: bool,
6094     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6095         self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into();
6096         self
6097     }
alpha_to_one_enable( mut self, alpha_to_one_enable: bool, ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6098     pub fn alpha_to_one_enable(
6099         mut self,
6100         alpha_to_one_enable: bool,
6101     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6102         self.inner.alpha_to_one_enable = alpha_to_one_enable.into();
6103         self
6104     }
6105     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6106     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6107     #[doc = r" valid extension structs can be pushed into the chain."]
6108     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6109     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineMultisampleStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineMultisampleStateCreateInfoBuilder<'a>6110     pub fn push_next<T: ExtendsPipelineMultisampleStateCreateInfo>(
6111         mut self,
6112         next: &'a mut T,
6113     ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
6114         unsafe {
6115             let next_ptr = next as *mut T as *mut BaseOutStructure;
6116             let last_next = ptr_chain_iter(next).last().unwrap();
6117             (*last_next).p_next = self.inner.p_next as _;
6118             self.inner.p_next = next_ptr as _;
6119         }
6120         self
6121     }
6122     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6123     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6124     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineMultisampleStateCreateInfo6125     pub fn build(self) -> PipelineMultisampleStateCreateInfo {
6126         self.inner
6127     }
6128 }
6129 #[repr(C)]
6130 #[derive(Copy, Clone, Default, Debug)]
6131 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendAttachmentState.html>"]
6132 pub struct PipelineColorBlendAttachmentState {
6133     pub blend_enable: Bool32,
6134     pub src_color_blend_factor: BlendFactor,
6135     pub dst_color_blend_factor: BlendFactor,
6136     pub color_blend_op: BlendOp,
6137     pub src_alpha_blend_factor: BlendFactor,
6138     pub dst_alpha_blend_factor: BlendFactor,
6139     pub alpha_blend_op: BlendOp,
6140     pub color_write_mask: ColorComponentFlags,
6141 }
6142 impl PipelineColorBlendAttachmentState {
builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a>6143     pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> {
6144         PipelineColorBlendAttachmentStateBuilder {
6145             inner: PipelineColorBlendAttachmentState::default(),
6146             marker: ::std::marker::PhantomData,
6147         }
6148     }
6149 }
6150 #[repr(transparent)]
6151 pub struct PipelineColorBlendAttachmentStateBuilder<'a> {
6152     inner: PipelineColorBlendAttachmentState,
6153     marker: ::std::marker::PhantomData<&'a ()>,
6154 }
6155 impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> {
6156     type Target = PipelineColorBlendAttachmentState;
deref(&self) -> &Self::Target6157     fn deref(&self) -> &Self::Target {
6158         &self.inner
6159     }
6160 }
6161 impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6162     fn deref_mut(&mut self) -> &mut Self::Target {
6163         &mut self.inner
6164     }
6165 }
6166 impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
blend_enable( mut self, blend_enable: bool, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6167     pub fn blend_enable(
6168         mut self,
6169         blend_enable: bool,
6170     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6171         self.inner.blend_enable = blend_enable.into();
6172         self
6173     }
src_color_blend_factor( mut self, src_color_blend_factor: BlendFactor, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6174     pub fn src_color_blend_factor(
6175         mut self,
6176         src_color_blend_factor: BlendFactor,
6177     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6178         self.inner.src_color_blend_factor = src_color_blend_factor;
6179         self
6180     }
dst_color_blend_factor( mut self, dst_color_blend_factor: BlendFactor, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6181     pub fn dst_color_blend_factor(
6182         mut self,
6183         dst_color_blend_factor: BlendFactor,
6184     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6185         self.inner.dst_color_blend_factor = dst_color_blend_factor;
6186         self
6187     }
color_blend_op( mut self, color_blend_op: BlendOp, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6188     pub fn color_blend_op(
6189         mut self,
6190         color_blend_op: BlendOp,
6191     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6192         self.inner.color_blend_op = color_blend_op;
6193         self
6194     }
src_alpha_blend_factor( mut self, src_alpha_blend_factor: BlendFactor, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6195     pub fn src_alpha_blend_factor(
6196         mut self,
6197         src_alpha_blend_factor: BlendFactor,
6198     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6199         self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
6200         self
6201     }
dst_alpha_blend_factor( mut self, dst_alpha_blend_factor: BlendFactor, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6202     pub fn dst_alpha_blend_factor(
6203         mut self,
6204         dst_alpha_blend_factor: BlendFactor,
6205     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6206         self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
6207         self
6208     }
alpha_blend_op( mut self, alpha_blend_op: BlendOp, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6209     pub fn alpha_blend_op(
6210         mut self,
6211         alpha_blend_op: BlendOp,
6212     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6213         self.inner.alpha_blend_op = alpha_blend_op;
6214         self
6215     }
color_write_mask( mut self, color_write_mask: ColorComponentFlags, ) -> PipelineColorBlendAttachmentStateBuilder<'a>6216     pub fn color_write_mask(
6217         mut self,
6218         color_write_mask: ColorComponentFlags,
6219     ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
6220         self.inner.color_write_mask = color_write_mask;
6221         self
6222     }
6223     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6224     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6225     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineColorBlendAttachmentState6226     pub fn build(self) -> PipelineColorBlendAttachmentState {
6227         self.inner
6228     }
6229 }
6230 #[repr(C)]
6231 #[derive(Copy, Clone, Debug)]
6232 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html>"]
6233 pub struct PipelineColorBlendStateCreateInfo {
6234     pub s_type: StructureType,
6235     pub p_next: *const c_void,
6236     pub flags: PipelineColorBlendStateCreateFlags,
6237     pub logic_op_enable: Bool32,
6238     pub logic_op: LogicOp,
6239     pub attachment_count: u32,
6240     pub p_attachments: *const PipelineColorBlendAttachmentState,
6241     pub blend_constants: [f32; 4],
6242 }
6243 impl ::std::default::Default for PipelineColorBlendStateCreateInfo {
default() -> PipelineColorBlendStateCreateInfo6244     fn default() -> PipelineColorBlendStateCreateInfo {
6245         PipelineColorBlendStateCreateInfo {
6246             s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
6247             p_next: ::std::ptr::null(),
6248             flags: PipelineColorBlendStateCreateFlags::default(),
6249             logic_op_enable: Bool32::default(),
6250             logic_op: LogicOp::default(),
6251             attachment_count: u32::default(),
6252             p_attachments: ::std::ptr::null(),
6253             blend_constants: unsafe { ::std::mem::zeroed() },
6254         }
6255     }
6256 }
6257 impl PipelineColorBlendStateCreateInfo {
builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a>6258     pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6259         PipelineColorBlendStateCreateInfoBuilder {
6260             inner: PipelineColorBlendStateCreateInfo::default(),
6261             marker: ::std::marker::PhantomData,
6262         }
6263     }
6264 }
6265 #[repr(transparent)]
6266 pub struct PipelineColorBlendStateCreateInfoBuilder<'a> {
6267     inner: PipelineColorBlendStateCreateInfo,
6268     marker: ::std::marker::PhantomData<&'a ()>,
6269 }
6270 pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {}
6271 impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
6272     type Target = PipelineColorBlendStateCreateInfo;
deref(&self) -> &Self::Target6273     fn deref(&self) -> &Self::Target {
6274         &self.inner
6275     }
6276 }
6277 impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6278     fn deref_mut(&mut self) -> &mut Self::Target {
6279         &mut self.inner
6280     }
6281 }
6282 impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineColorBlendStateCreateFlags, ) -> PipelineColorBlendStateCreateInfoBuilder<'a>6283     pub fn flags(
6284         mut self,
6285         flags: PipelineColorBlendStateCreateFlags,
6286     ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6287         self.inner.flags = flags;
6288         self
6289     }
logic_op_enable( mut self, logic_op_enable: bool, ) -> PipelineColorBlendStateCreateInfoBuilder<'a>6290     pub fn logic_op_enable(
6291         mut self,
6292         logic_op_enable: bool,
6293     ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6294         self.inner.logic_op_enable = logic_op_enable.into();
6295         self
6296     }
logic_op(mut self, logic_op: LogicOp) -> PipelineColorBlendStateCreateInfoBuilder<'a>6297     pub fn logic_op(mut self, logic_op: LogicOp) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6298         self.inner.logic_op = logic_op;
6299         self
6300     }
attachments( mut self, attachments: &'a [PipelineColorBlendAttachmentState], ) -> PipelineColorBlendStateCreateInfoBuilder<'a>6301     pub fn attachments(
6302         mut self,
6303         attachments: &'a [PipelineColorBlendAttachmentState],
6304     ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6305         self.inner.attachment_count = attachments.len() as _;
6306         self.inner.p_attachments = attachments.as_ptr();
6307         self
6308     }
blend_constants( mut self, blend_constants: [f32; 4], ) -> PipelineColorBlendStateCreateInfoBuilder<'a>6309     pub fn blend_constants(
6310         mut self,
6311         blend_constants: [f32; 4],
6312     ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6313         self.inner.blend_constants = blend_constants;
6314         self
6315     }
6316     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6317     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6318     #[doc = r" valid extension structs can be pushed into the chain."]
6319     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6320     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineColorBlendStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineColorBlendStateCreateInfoBuilder<'a>6321     pub fn push_next<T: ExtendsPipelineColorBlendStateCreateInfo>(
6322         mut self,
6323         next: &'a mut T,
6324     ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
6325         unsafe {
6326             let next_ptr = next as *mut T as *mut BaseOutStructure;
6327             let last_next = ptr_chain_iter(next).last().unwrap();
6328             (*last_next).p_next = self.inner.p_next as _;
6329             self.inner.p_next = next_ptr as _;
6330         }
6331         self
6332     }
6333     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6334     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6335     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineColorBlendStateCreateInfo6336     pub fn build(self) -> PipelineColorBlendStateCreateInfo {
6337         self.inner
6338     }
6339 }
6340 #[repr(C)]
6341 #[derive(Copy, Clone, Debug)]
6342 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateInfo.html>"]
6343 pub struct PipelineDynamicStateCreateInfo {
6344     pub s_type: StructureType,
6345     pub p_next: *const c_void,
6346     pub flags: PipelineDynamicStateCreateFlags,
6347     pub dynamic_state_count: u32,
6348     pub p_dynamic_states: *const DynamicState,
6349 }
6350 impl ::std::default::Default for PipelineDynamicStateCreateInfo {
default() -> PipelineDynamicStateCreateInfo6351     fn default() -> PipelineDynamicStateCreateInfo {
6352         PipelineDynamicStateCreateInfo {
6353             s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO,
6354             p_next: ::std::ptr::null(),
6355             flags: PipelineDynamicStateCreateFlags::default(),
6356             dynamic_state_count: u32::default(),
6357             p_dynamic_states: ::std::ptr::null(),
6358         }
6359     }
6360 }
6361 impl PipelineDynamicStateCreateInfo {
builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a>6362     pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> {
6363         PipelineDynamicStateCreateInfoBuilder {
6364             inner: PipelineDynamicStateCreateInfo::default(),
6365             marker: ::std::marker::PhantomData,
6366         }
6367     }
6368 }
6369 #[repr(transparent)]
6370 pub struct PipelineDynamicStateCreateInfoBuilder<'a> {
6371     inner: PipelineDynamicStateCreateInfo,
6372     marker: ::std::marker::PhantomData<&'a ()>,
6373 }
6374 pub unsafe trait ExtendsPipelineDynamicStateCreateInfo {}
6375 impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
6376     type Target = PipelineDynamicStateCreateInfo;
deref(&self) -> &Self::Target6377     fn deref(&self) -> &Self::Target {
6378         &self.inner
6379     }
6380 }
6381 impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6382     fn deref_mut(&mut self) -> &mut Self::Target {
6383         &mut self.inner
6384     }
6385 }
6386 impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineDynamicStateCreateFlags, ) -> PipelineDynamicStateCreateInfoBuilder<'a>6387     pub fn flags(
6388         mut self,
6389         flags: PipelineDynamicStateCreateFlags,
6390     ) -> PipelineDynamicStateCreateInfoBuilder<'a> {
6391         self.inner.flags = flags;
6392         self
6393     }
dynamic_states( mut self, dynamic_states: &'a [DynamicState], ) -> PipelineDynamicStateCreateInfoBuilder<'a>6394     pub fn dynamic_states(
6395         mut self,
6396         dynamic_states: &'a [DynamicState],
6397     ) -> PipelineDynamicStateCreateInfoBuilder<'a> {
6398         self.inner.dynamic_state_count = dynamic_states.len() as _;
6399         self.inner.p_dynamic_states = dynamic_states.as_ptr();
6400         self
6401     }
6402     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6403     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6404     #[doc = r" valid extension structs can be pushed into the chain."]
6405     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6406     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineDynamicStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineDynamicStateCreateInfoBuilder<'a>6407     pub fn push_next<T: ExtendsPipelineDynamicStateCreateInfo>(
6408         mut self,
6409         next: &'a mut T,
6410     ) -> PipelineDynamicStateCreateInfoBuilder<'a> {
6411         unsafe {
6412             let next_ptr = next as *mut T as *mut BaseOutStructure;
6413             let last_next = ptr_chain_iter(next).last().unwrap();
6414             (*last_next).p_next = self.inner.p_next as _;
6415             self.inner.p_next = next_ptr as _;
6416         }
6417         self
6418     }
6419     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6420     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6421     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineDynamicStateCreateInfo6422     pub fn build(self) -> PipelineDynamicStateCreateInfo {
6423         self.inner
6424     }
6425 }
6426 #[repr(C)]
6427 #[derive(Copy, Clone, Default, Debug)]
6428 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilOpState.html>"]
6429 pub struct StencilOpState {
6430     pub fail_op: StencilOp,
6431     pub pass_op: StencilOp,
6432     pub depth_fail_op: StencilOp,
6433     pub compare_op: CompareOp,
6434     pub compare_mask: u32,
6435     pub write_mask: u32,
6436     pub reference: u32,
6437 }
6438 impl StencilOpState {
builder<'a>() -> StencilOpStateBuilder<'a>6439     pub fn builder<'a>() -> StencilOpStateBuilder<'a> {
6440         StencilOpStateBuilder {
6441             inner: StencilOpState::default(),
6442             marker: ::std::marker::PhantomData,
6443         }
6444     }
6445 }
6446 #[repr(transparent)]
6447 pub struct StencilOpStateBuilder<'a> {
6448     inner: StencilOpState,
6449     marker: ::std::marker::PhantomData<&'a ()>,
6450 }
6451 impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> {
6452     type Target = StencilOpState;
deref(&self) -> &Self::Target6453     fn deref(&self) -> &Self::Target {
6454         &self.inner
6455     }
6456 }
6457 impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6458     fn deref_mut(&mut self) -> &mut Self::Target {
6459         &mut self.inner
6460     }
6461 }
6462 impl<'a> StencilOpStateBuilder<'a> {
fail_op(mut self, fail_op: StencilOp) -> StencilOpStateBuilder<'a>6463     pub fn fail_op(mut self, fail_op: StencilOp) -> StencilOpStateBuilder<'a> {
6464         self.inner.fail_op = fail_op;
6465         self
6466     }
pass_op(mut self, pass_op: StencilOp) -> StencilOpStateBuilder<'a>6467     pub fn pass_op(mut self, pass_op: StencilOp) -> StencilOpStateBuilder<'a> {
6468         self.inner.pass_op = pass_op;
6469         self
6470     }
depth_fail_op(mut self, depth_fail_op: StencilOp) -> StencilOpStateBuilder<'a>6471     pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> StencilOpStateBuilder<'a> {
6472         self.inner.depth_fail_op = depth_fail_op;
6473         self
6474     }
compare_op(mut self, compare_op: CompareOp) -> StencilOpStateBuilder<'a>6475     pub fn compare_op(mut self, compare_op: CompareOp) -> StencilOpStateBuilder<'a> {
6476         self.inner.compare_op = compare_op;
6477         self
6478     }
compare_mask(mut self, compare_mask: u32) -> StencilOpStateBuilder<'a>6479     pub fn compare_mask(mut self, compare_mask: u32) -> StencilOpStateBuilder<'a> {
6480         self.inner.compare_mask = compare_mask;
6481         self
6482     }
write_mask(mut self, write_mask: u32) -> StencilOpStateBuilder<'a>6483     pub fn write_mask(mut self, write_mask: u32) -> StencilOpStateBuilder<'a> {
6484         self.inner.write_mask = write_mask;
6485         self
6486     }
reference(mut self, reference: u32) -> StencilOpStateBuilder<'a>6487     pub fn reference(mut self, reference: u32) -> StencilOpStateBuilder<'a> {
6488         self.inner.reference = reference;
6489         self
6490     }
6491     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6492     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6493     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> StencilOpState6494     pub fn build(self) -> StencilOpState {
6495         self.inner
6496     }
6497 }
6498 #[repr(C)]
6499 #[derive(Copy, Clone, Debug)]
6500 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html>"]
6501 pub struct PipelineDepthStencilStateCreateInfo {
6502     pub s_type: StructureType,
6503     pub p_next: *const c_void,
6504     pub flags: PipelineDepthStencilStateCreateFlags,
6505     pub depth_test_enable: Bool32,
6506     pub depth_write_enable: Bool32,
6507     pub depth_compare_op: CompareOp,
6508     pub depth_bounds_test_enable: Bool32,
6509     pub stencil_test_enable: Bool32,
6510     pub front: StencilOpState,
6511     pub back: StencilOpState,
6512     pub min_depth_bounds: f32,
6513     pub max_depth_bounds: f32,
6514 }
6515 impl ::std::default::Default for PipelineDepthStencilStateCreateInfo {
default() -> PipelineDepthStencilStateCreateInfo6516     fn default() -> PipelineDepthStencilStateCreateInfo {
6517         PipelineDepthStencilStateCreateInfo {
6518             s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
6519             p_next: ::std::ptr::null(),
6520             flags: PipelineDepthStencilStateCreateFlags::default(),
6521             depth_test_enable: Bool32::default(),
6522             depth_write_enable: Bool32::default(),
6523             depth_compare_op: CompareOp::default(),
6524             depth_bounds_test_enable: Bool32::default(),
6525             stencil_test_enable: Bool32::default(),
6526             front: StencilOpState::default(),
6527             back: StencilOpState::default(),
6528             min_depth_bounds: f32::default(),
6529             max_depth_bounds: f32::default(),
6530         }
6531     }
6532 }
6533 impl PipelineDepthStencilStateCreateInfo {
builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a>6534     pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6535         PipelineDepthStencilStateCreateInfoBuilder {
6536             inner: PipelineDepthStencilStateCreateInfo::default(),
6537             marker: ::std::marker::PhantomData,
6538         }
6539     }
6540 }
6541 #[repr(transparent)]
6542 pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> {
6543     inner: PipelineDepthStencilStateCreateInfo,
6544     marker: ::std::marker::PhantomData<&'a ()>,
6545 }
6546 pub unsafe trait ExtendsPipelineDepthStencilStateCreateInfo {}
6547 impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
6548     type Target = PipelineDepthStencilStateCreateInfo;
deref(&self) -> &Self::Target6549     fn deref(&self) -> &Self::Target {
6550         &self.inner
6551     }
6552 }
6553 impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6554     fn deref_mut(&mut self) -> &mut Self::Target {
6555         &mut self.inner
6556     }
6557 }
6558 impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineDepthStencilStateCreateFlags, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6559     pub fn flags(
6560         mut self,
6561         flags: PipelineDepthStencilStateCreateFlags,
6562     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6563         self.inner.flags = flags;
6564         self
6565     }
depth_test_enable( mut self, depth_test_enable: bool, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6566     pub fn depth_test_enable(
6567         mut self,
6568         depth_test_enable: bool,
6569     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6570         self.inner.depth_test_enable = depth_test_enable.into();
6571         self
6572     }
depth_write_enable( mut self, depth_write_enable: bool, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6573     pub fn depth_write_enable(
6574         mut self,
6575         depth_write_enable: bool,
6576     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6577         self.inner.depth_write_enable = depth_write_enable.into();
6578         self
6579     }
depth_compare_op( mut self, depth_compare_op: CompareOp, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6580     pub fn depth_compare_op(
6581         mut self,
6582         depth_compare_op: CompareOp,
6583     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6584         self.inner.depth_compare_op = depth_compare_op;
6585         self
6586     }
depth_bounds_test_enable( mut self, depth_bounds_test_enable: bool, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6587     pub fn depth_bounds_test_enable(
6588         mut self,
6589         depth_bounds_test_enable: bool,
6590     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6591         self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into();
6592         self
6593     }
stencil_test_enable( mut self, stencil_test_enable: bool, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6594     pub fn stencil_test_enable(
6595         mut self,
6596         stencil_test_enable: bool,
6597     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6598         self.inner.stencil_test_enable = stencil_test_enable.into();
6599         self
6600     }
front( mut self, front: StencilOpState, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6601     pub fn front(
6602         mut self,
6603         front: StencilOpState,
6604     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6605         self.inner.front = front;
6606         self
6607     }
back(mut self, back: StencilOpState) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6608     pub fn back(mut self, back: StencilOpState) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6609         self.inner.back = back;
6610         self
6611     }
min_depth_bounds( mut self, min_depth_bounds: f32, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6612     pub fn min_depth_bounds(
6613         mut self,
6614         min_depth_bounds: f32,
6615     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6616         self.inner.min_depth_bounds = min_depth_bounds;
6617         self
6618     }
max_depth_bounds( mut self, max_depth_bounds: f32, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6619     pub fn max_depth_bounds(
6620         mut self,
6621         max_depth_bounds: f32,
6622     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6623         self.inner.max_depth_bounds = max_depth_bounds;
6624         self
6625     }
6626     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6627     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6628     #[doc = r" valid extension structs can be pushed into the chain."]
6629     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6630     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineDepthStencilStateCreateInfo>( mut self, next: &'a mut T, ) -> PipelineDepthStencilStateCreateInfoBuilder<'a>6631     pub fn push_next<T: ExtendsPipelineDepthStencilStateCreateInfo>(
6632         mut self,
6633         next: &'a mut T,
6634     ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
6635         unsafe {
6636             let next_ptr = next as *mut T as *mut BaseOutStructure;
6637             let last_next = ptr_chain_iter(next).last().unwrap();
6638             (*last_next).p_next = self.inner.p_next as _;
6639             self.inner.p_next = next_ptr as _;
6640         }
6641         self
6642     }
6643     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6644     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6645     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineDepthStencilStateCreateInfo6646     pub fn build(self) -> PipelineDepthStencilStateCreateInfo {
6647         self.inner
6648     }
6649 }
6650 #[repr(C)]
6651 #[derive(Copy, Clone, Debug)]
6652 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineCreateInfo.html>"]
6653 pub struct GraphicsPipelineCreateInfo {
6654     pub s_type: StructureType,
6655     pub p_next: *const c_void,
6656     pub flags: PipelineCreateFlags,
6657     pub stage_count: u32,
6658     pub p_stages: *const PipelineShaderStageCreateInfo,
6659     pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
6660     pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo,
6661     pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
6662     pub p_viewport_state: *const PipelineViewportStateCreateInfo,
6663     pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo,
6664     pub p_multisample_state: *const PipelineMultisampleStateCreateInfo,
6665     pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo,
6666     pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo,
6667     pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
6668     pub layout: PipelineLayout,
6669     pub render_pass: RenderPass,
6670     pub subpass: u32,
6671     pub base_pipeline_handle: Pipeline,
6672     pub base_pipeline_index: i32,
6673 }
6674 impl ::std::default::Default for GraphicsPipelineCreateInfo {
default() -> GraphicsPipelineCreateInfo6675     fn default() -> GraphicsPipelineCreateInfo {
6676         GraphicsPipelineCreateInfo {
6677             s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO,
6678             p_next: ::std::ptr::null(),
6679             flags: PipelineCreateFlags::default(),
6680             stage_count: u32::default(),
6681             p_stages: ::std::ptr::null(),
6682             p_vertex_input_state: ::std::ptr::null(),
6683             p_input_assembly_state: ::std::ptr::null(),
6684             p_tessellation_state: ::std::ptr::null(),
6685             p_viewport_state: ::std::ptr::null(),
6686             p_rasterization_state: ::std::ptr::null(),
6687             p_multisample_state: ::std::ptr::null(),
6688             p_depth_stencil_state: ::std::ptr::null(),
6689             p_color_blend_state: ::std::ptr::null(),
6690             p_dynamic_state: ::std::ptr::null(),
6691             layout: PipelineLayout::default(),
6692             render_pass: RenderPass::default(),
6693             subpass: u32::default(),
6694             base_pipeline_handle: Pipeline::default(),
6695             base_pipeline_index: i32::default(),
6696         }
6697     }
6698 }
6699 impl GraphicsPipelineCreateInfo {
builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a>6700     pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> {
6701         GraphicsPipelineCreateInfoBuilder {
6702             inner: GraphicsPipelineCreateInfo::default(),
6703             marker: ::std::marker::PhantomData,
6704         }
6705     }
6706 }
6707 #[repr(transparent)]
6708 pub struct GraphicsPipelineCreateInfoBuilder<'a> {
6709     inner: GraphicsPipelineCreateInfo,
6710     marker: ::std::marker::PhantomData<&'a ()>,
6711 }
6712 pub unsafe trait ExtendsGraphicsPipelineCreateInfo {}
6713 impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> {
6714     type Target = GraphicsPipelineCreateInfo;
deref(&self) -> &Self::Target6715     fn deref(&self) -> &Self::Target {
6716         &self.inner
6717     }
6718 }
6719 impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6720     fn deref_mut(&mut self) -> &mut Self::Target {
6721         &mut self.inner
6722     }
6723 }
6724 impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
flags(mut self, flags: PipelineCreateFlags) -> GraphicsPipelineCreateInfoBuilder<'a>6725     pub fn flags(mut self, flags: PipelineCreateFlags) -> GraphicsPipelineCreateInfoBuilder<'a> {
6726         self.inner.flags = flags;
6727         self
6728     }
stages( mut self, stages: &'a [PipelineShaderStageCreateInfo], ) -> GraphicsPipelineCreateInfoBuilder<'a>6729     pub fn stages(
6730         mut self,
6731         stages: &'a [PipelineShaderStageCreateInfo],
6732     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6733         self.inner.stage_count = stages.len() as _;
6734         self.inner.p_stages = stages.as_ptr();
6735         self
6736     }
vertex_input_state( mut self, vertex_input_state: &'a PipelineVertexInputStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6737     pub fn vertex_input_state(
6738         mut self,
6739         vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
6740     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6741         self.inner.p_vertex_input_state = vertex_input_state;
6742         self
6743     }
input_assembly_state( mut self, input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6744     pub fn input_assembly_state(
6745         mut self,
6746         input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo,
6747     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6748         self.inner.p_input_assembly_state = input_assembly_state;
6749         self
6750     }
tessellation_state( mut self, tessellation_state: &'a PipelineTessellationStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6751     pub fn tessellation_state(
6752         mut self,
6753         tessellation_state: &'a PipelineTessellationStateCreateInfo,
6754     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6755         self.inner.p_tessellation_state = tessellation_state;
6756         self
6757     }
viewport_state( mut self, viewport_state: &'a PipelineViewportStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6758     pub fn viewport_state(
6759         mut self,
6760         viewport_state: &'a PipelineViewportStateCreateInfo,
6761     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6762         self.inner.p_viewport_state = viewport_state;
6763         self
6764     }
rasterization_state( mut self, rasterization_state: &'a PipelineRasterizationStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6765     pub fn rasterization_state(
6766         mut self,
6767         rasterization_state: &'a PipelineRasterizationStateCreateInfo,
6768     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6769         self.inner.p_rasterization_state = rasterization_state;
6770         self
6771     }
multisample_state( mut self, multisample_state: &'a PipelineMultisampleStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6772     pub fn multisample_state(
6773         mut self,
6774         multisample_state: &'a PipelineMultisampleStateCreateInfo,
6775     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6776         self.inner.p_multisample_state = multisample_state;
6777         self
6778     }
depth_stencil_state( mut self, depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6779     pub fn depth_stencil_state(
6780         mut self,
6781         depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo,
6782     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6783         self.inner.p_depth_stencil_state = depth_stencil_state;
6784         self
6785     }
color_blend_state( mut self, color_blend_state: &'a PipelineColorBlendStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6786     pub fn color_blend_state(
6787         mut self,
6788         color_blend_state: &'a PipelineColorBlendStateCreateInfo,
6789     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6790         self.inner.p_color_blend_state = color_blend_state;
6791         self
6792     }
dynamic_state( mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo, ) -> GraphicsPipelineCreateInfoBuilder<'a>6793     pub fn dynamic_state(
6794         mut self,
6795         dynamic_state: &'a PipelineDynamicStateCreateInfo,
6796     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6797         self.inner.p_dynamic_state = dynamic_state;
6798         self
6799     }
layout(mut self, layout: PipelineLayout) -> GraphicsPipelineCreateInfoBuilder<'a>6800     pub fn layout(mut self, layout: PipelineLayout) -> GraphicsPipelineCreateInfoBuilder<'a> {
6801         self.inner.layout = layout;
6802         self
6803     }
render_pass(mut self, render_pass: RenderPass) -> GraphicsPipelineCreateInfoBuilder<'a>6804     pub fn render_pass(mut self, render_pass: RenderPass) -> GraphicsPipelineCreateInfoBuilder<'a> {
6805         self.inner.render_pass = render_pass;
6806         self
6807     }
subpass(mut self, subpass: u32) -> GraphicsPipelineCreateInfoBuilder<'a>6808     pub fn subpass(mut self, subpass: u32) -> GraphicsPipelineCreateInfoBuilder<'a> {
6809         self.inner.subpass = subpass;
6810         self
6811     }
base_pipeline_handle( mut self, base_pipeline_handle: Pipeline, ) -> GraphicsPipelineCreateInfoBuilder<'a>6812     pub fn base_pipeline_handle(
6813         mut self,
6814         base_pipeline_handle: Pipeline,
6815     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6816         self.inner.base_pipeline_handle = base_pipeline_handle;
6817         self
6818     }
base_pipeline_index( mut self, base_pipeline_index: i32, ) -> GraphicsPipelineCreateInfoBuilder<'a>6819     pub fn base_pipeline_index(
6820         mut self,
6821         base_pipeline_index: i32,
6822     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6823         self.inner.base_pipeline_index = base_pipeline_index;
6824         self
6825     }
6826     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6827     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6828     #[doc = r" valid extension structs can be pushed into the chain."]
6829     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6830     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGraphicsPipelineCreateInfo>( mut self, next: &'a mut T, ) -> GraphicsPipelineCreateInfoBuilder<'a>6831     pub fn push_next<T: ExtendsGraphicsPipelineCreateInfo>(
6832         mut self,
6833         next: &'a mut T,
6834     ) -> GraphicsPipelineCreateInfoBuilder<'a> {
6835         unsafe {
6836             let next_ptr = next as *mut T as *mut BaseOutStructure;
6837             let last_next = ptr_chain_iter(next).last().unwrap();
6838             (*last_next).p_next = self.inner.p_next as _;
6839             self.inner.p_next = next_ptr as _;
6840         }
6841         self
6842     }
6843     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6844     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6845     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GraphicsPipelineCreateInfo6846     pub fn build(self) -> GraphicsPipelineCreateInfo {
6847         self.inner
6848     }
6849 }
6850 #[repr(C)]
6851 #[derive(Copy, Clone, Debug)]
6852 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateInfo.html>"]
6853 pub struct PipelineCacheCreateInfo {
6854     pub s_type: StructureType,
6855     pub p_next: *const c_void,
6856     pub flags: PipelineCacheCreateFlags,
6857     pub initial_data_size: usize,
6858     pub p_initial_data: *const c_void,
6859 }
6860 impl ::std::default::Default for PipelineCacheCreateInfo {
default() -> PipelineCacheCreateInfo6861     fn default() -> PipelineCacheCreateInfo {
6862         PipelineCacheCreateInfo {
6863             s_type: StructureType::PIPELINE_CACHE_CREATE_INFO,
6864             p_next: ::std::ptr::null(),
6865             flags: PipelineCacheCreateFlags::default(),
6866             initial_data_size: usize::default(),
6867             p_initial_data: ::std::ptr::null(),
6868         }
6869     }
6870 }
6871 impl PipelineCacheCreateInfo {
builder<'a>() -> PipelineCacheCreateInfoBuilder<'a>6872     pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> {
6873         PipelineCacheCreateInfoBuilder {
6874             inner: PipelineCacheCreateInfo::default(),
6875             marker: ::std::marker::PhantomData,
6876         }
6877     }
6878 }
6879 #[repr(transparent)]
6880 pub struct PipelineCacheCreateInfoBuilder<'a> {
6881     inner: PipelineCacheCreateInfo,
6882     marker: ::std::marker::PhantomData<&'a ()>,
6883 }
6884 pub unsafe trait ExtendsPipelineCacheCreateInfo {}
6885 impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> {
6886     type Target = PipelineCacheCreateInfo;
deref(&self) -> &Self::Target6887     fn deref(&self) -> &Self::Target {
6888         &self.inner
6889     }
6890 }
6891 impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6892     fn deref_mut(&mut self) -> &mut Self::Target {
6893         &mut self.inner
6894     }
6895 }
6896 impl<'a> PipelineCacheCreateInfoBuilder<'a> {
flags(mut self, flags: PipelineCacheCreateFlags) -> PipelineCacheCreateInfoBuilder<'a>6897     pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> PipelineCacheCreateInfoBuilder<'a> {
6898         self.inner.flags = flags;
6899         self
6900     }
initial_data(mut self, initial_data: &'a [u8]) -> PipelineCacheCreateInfoBuilder<'a>6901     pub fn initial_data(mut self, initial_data: &'a [u8]) -> PipelineCacheCreateInfoBuilder<'a> {
6902         self.inner.initial_data_size = initial_data.len() as _;
6903         self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
6904         self
6905     }
6906     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
6907     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
6908     #[doc = r" valid extension structs can be pushed into the chain."]
6909     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
6910     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineCacheCreateInfo>( mut self, next: &'a mut T, ) -> PipelineCacheCreateInfoBuilder<'a>6911     pub fn push_next<T: ExtendsPipelineCacheCreateInfo>(
6912         mut self,
6913         next: &'a mut T,
6914     ) -> PipelineCacheCreateInfoBuilder<'a> {
6915         unsafe {
6916             let next_ptr = next as *mut T as *mut BaseOutStructure;
6917             let last_next = ptr_chain_iter(next).last().unwrap();
6918             (*last_next).p_next = self.inner.p_next as _;
6919             self.inner.p_next = next_ptr as _;
6920         }
6921         self
6922     }
6923     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6924     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6925     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCacheCreateInfo6926     pub fn build(self) -> PipelineCacheCreateInfo {
6927         self.inner
6928     }
6929 }
6930 #[repr(C)]
6931 #[derive(Copy, Clone, Default, Debug)]
6932 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPushConstantRange.html>"]
6933 pub struct PushConstantRange {
6934     pub stage_flags: ShaderStageFlags,
6935     pub offset: u32,
6936     pub size: u32,
6937 }
6938 impl PushConstantRange {
builder<'a>() -> PushConstantRangeBuilder<'a>6939     pub fn builder<'a>() -> PushConstantRangeBuilder<'a> {
6940         PushConstantRangeBuilder {
6941             inner: PushConstantRange::default(),
6942             marker: ::std::marker::PhantomData,
6943         }
6944     }
6945 }
6946 #[repr(transparent)]
6947 pub struct PushConstantRangeBuilder<'a> {
6948     inner: PushConstantRange,
6949     marker: ::std::marker::PhantomData<&'a ()>,
6950 }
6951 impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> {
6952     type Target = PushConstantRange;
deref(&self) -> &Self::Target6953     fn deref(&self) -> &Self::Target {
6954         &self.inner
6955     }
6956 }
6957 impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target6958     fn deref_mut(&mut self) -> &mut Self::Target {
6959         &mut self.inner
6960     }
6961 }
6962 impl<'a> PushConstantRangeBuilder<'a> {
stage_flags(mut self, stage_flags: ShaderStageFlags) -> PushConstantRangeBuilder<'a>6963     pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> PushConstantRangeBuilder<'a> {
6964         self.inner.stage_flags = stage_flags;
6965         self
6966     }
offset(mut self, offset: u32) -> PushConstantRangeBuilder<'a>6967     pub fn offset(mut self, offset: u32) -> PushConstantRangeBuilder<'a> {
6968         self.inner.offset = offset;
6969         self
6970     }
size(mut self, size: u32) -> PushConstantRangeBuilder<'a>6971     pub fn size(mut self, size: u32) -> PushConstantRangeBuilder<'a> {
6972         self.inner.size = size;
6973         self
6974     }
6975     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
6976     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
6977     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PushConstantRange6978     pub fn build(self) -> PushConstantRange {
6979         self.inner
6980     }
6981 }
6982 #[repr(C)]
6983 #[derive(Copy, Clone, Debug)]
6984 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateInfo.html>"]
6985 pub struct PipelineLayoutCreateInfo {
6986     pub s_type: StructureType,
6987     pub p_next: *const c_void,
6988     pub flags: PipelineLayoutCreateFlags,
6989     pub set_layout_count: u32,
6990     pub p_set_layouts: *const DescriptorSetLayout,
6991     pub push_constant_range_count: u32,
6992     pub p_push_constant_ranges: *const PushConstantRange,
6993 }
6994 impl ::std::default::Default for PipelineLayoutCreateInfo {
default() -> PipelineLayoutCreateInfo6995     fn default() -> PipelineLayoutCreateInfo {
6996         PipelineLayoutCreateInfo {
6997             s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO,
6998             p_next: ::std::ptr::null(),
6999             flags: PipelineLayoutCreateFlags::default(),
7000             set_layout_count: u32::default(),
7001             p_set_layouts: ::std::ptr::null(),
7002             push_constant_range_count: u32::default(),
7003             p_push_constant_ranges: ::std::ptr::null(),
7004         }
7005     }
7006 }
7007 impl PipelineLayoutCreateInfo {
builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a>7008     pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> {
7009         PipelineLayoutCreateInfoBuilder {
7010             inner: PipelineLayoutCreateInfo::default(),
7011             marker: ::std::marker::PhantomData,
7012         }
7013     }
7014 }
7015 #[repr(transparent)]
7016 pub struct PipelineLayoutCreateInfoBuilder<'a> {
7017     inner: PipelineLayoutCreateInfo,
7018     marker: ::std::marker::PhantomData<&'a ()>,
7019 }
7020 pub unsafe trait ExtendsPipelineLayoutCreateInfo {}
7021 impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> {
7022     type Target = PipelineLayoutCreateInfo;
deref(&self) -> &Self::Target7023     fn deref(&self) -> &Self::Target {
7024         &self.inner
7025     }
7026 }
7027 impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7028     fn deref_mut(&mut self) -> &mut Self::Target {
7029         &mut self.inner
7030     }
7031 }
7032 impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
flags( mut self, flags: PipelineLayoutCreateFlags, ) -> PipelineLayoutCreateInfoBuilder<'a>7033     pub fn flags(
7034         mut self,
7035         flags: PipelineLayoutCreateFlags,
7036     ) -> PipelineLayoutCreateInfoBuilder<'a> {
7037         self.inner.flags = flags;
7038         self
7039     }
set_layouts( mut self, set_layouts: &'a [DescriptorSetLayout], ) -> PipelineLayoutCreateInfoBuilder<'a>7040     pub fn set_layouts(
7041         mut self,
7042         set_layouts: &'a [DescriptorSetLayout],
7043     ) -> PipelineLayoutCreateInfoBuilder<'a> {
7044         self.inner.set_layout_count = set_layouts.len() as _;
7045         self.inner.p_set_layouts = set_layouts.as_ptr();
7046         self
7047     }
push_constant_ranges( mut self, push_constant_ranges: &'a [PushConstantRange], ) -> PipelineLayoutCreateInfoBuilder<'a>7048     pub fn push_constant_ranges(
7049         mut self,
7050         push_constant_ranges: &'a [PushConstantRange],
7051     ) -> PipelineLayoutCreateInfoBuilder<'a> {
7052         self.inner.push_constant_range_count = push_constant_ranges.len() as _;
7053         self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
7054         self
7055     }
7056     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7057     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7058     #[doc = r" valid extension structs can be pushed into the chain."]
7059     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7060     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineLayoutCreateInfo>( mut self, next: &'a mut T, ) -> PipelineLayoutCreateInfoBuilder<'a>7061     pub fn push_next<T: ExtendsPipelineLayoutCreateInfo>(
7062         mut self,
7063         next: &'a mut T,
7064     ) -> PipelineLayoutCreateInfoBuilder<'a> {
7065         unsafe {
7066             let next_ptr = next as *mut T as *mut BaseOutStructure;
7067             let last_next = ptr_chain_iter(next).last().unwrap();
7068             (*last_next).p_next = self.inner.p_next as _;
7069             self.inner.p_next = next_ptr as _;
7070         }
7071         self
7072     }
7073     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7074     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7075     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineLayoutCreateInfo7076     pub fn build(self) -> PipelineLayoutCreateInfo {
7077         self.inner
7078     }
7079 }
7080 #[repr(C)]
7081 #[derive(Copy, Clone, Debug)]
7082 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateInfo.html>"]
7083 pub struct SamplerCreateInfo {
7084     pub s_type: StructureType,
7085     pub p_next: *const c_void,
7086     pub flags: SamplerCreateFlags,
7087     pub mag_filter: Filter,
7088     pub min_filter: Filter,
7089     pub mipmap_mode: SamplerMipmapMode,
7090     pub address_mode_u: SamplerAddressMode,
7091     pub address_mode_v: SamplerAddressMode,
7092     pub address_mode_w: SamplerAddressMode,
7093     pub mip_lod_bias: f32,
7094     pub anisotropy_enable: Bool32,
7095     pub max_anisotropy: f32,
7096     pub compare_enable: Bool32,
7097     pub compare_op: CompareOp,
7098     pub min_lod: f32,
7099     pub max_lod: f32,
7100     pub border_color: BorderColor,
7101     pub unnormalized_coordinates: Bool32,
7102 }
7103 impl ::std::default::Default for SamplerCreateInfo {
default() -> SamplerCreateInfo7104     fn default() -> SamplerCreateInfo {
7105         SamplerCreateInfo {
7106             s_type: StructureType::SAMPLER_CREATE_INFO,
7107             p_next: ::std::ptr::null(),
7108             flags: SamplerCreateFlags::default(),
7109             mag_filter: Filter::default(),
7110             min_filter: Filter::default(),
7111             mipmap_mode: SamplerMipmapMode::default(),
7112             address_mode_u: SamplerAddressMode::default(),
7113             address_mode_v: SamplerAddressMode::default(),
7114             address_mode_w: SamplerAddressMode::default(),
7115             mip_lod_bias: f32::default(),
7116             anisotropy_enable: Bool32::default(),
7117             max_anisotropy: f32::default(),
7118             compare_enable: Bool32::default(),
7119             compare_op: CompareOp::default(),
7120             min_lod: f32::default(),
7121             max_lod: f32::default(),
7122             border_color: BorderColor::default(),
7123             unnormalized_coordinates: Bool32::default(),
7124         }
7125     }
7126 }
7127 impl SamplerCreateInfo {
builder<'a>() -> SamplerCreateInfoBuilder<'a>7128     pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> {
7129         SamplerCreateInfoBuilder {
7130             inner: SamplerCreateInfo::default(),
7131             marker: ::std::marker::PhantomData,
7132         }
7133     }
7134 }
7135 #[repr(transparent)]
7136 pub struct SamplerCreateInfoBuilder<'a> {
7137     inner: SamplerCreateInfo,
7138     marker: ::std::marker::PhantomData<&'a ()>,
7139 }
7140 pub unsafe trait ExtendsSamplerCreateInfo {}
7141 impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> {
7142     type Target = SamplerCreateInfo;
deref(&self) -> &Self::Target7143     fn deref(&self) -> &Self::Target {
7144         &self.inner
7145     }
7146 }
7147 impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7148     fn deref_mut(&mut self) -> &mut Self::Target {
7149         &mut self.inner
7150     }
7151 }
7152 impl<'a> SamplerCreateInfoBuilder<'a> {
flags(mut self, flags: SamplerCreateFlags) -> SamplerCreateInfoBuilder<'a>7153     pub fn flags(mut self, flags: SamplerCreateFlags) -> SamplerCreateInfoBuilder<'a> {
7154         self.inner.flags = flags;
7155         self
7156     }
mag_filter(mut self, mag_filter: Filter) -> SamplerCreateInfoBuilder<'a>7157     pub fn mag_filter(mut self, mag_filter: Filter) -> SamplerCreateInfoBuilder<'a> {
7158         self.inner.mag_filter = mag_filter;
7159         self
7160     }
min_filter(mut self, min_filter: Filter) -> SamplerCreateInfoBuilder<'a>7161     pub fn min_filter(mut self, min_filter: Filter) -> SamplerCreateInfoBuilder<'a> {
7162         self.inner.min_filter = min_filter;
7163         self
7164     }
mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> SamplerCreateInfoBuilder<'a>7165     pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> SamplerCreateInfoBuilder<'a> {
7166         self.inner.mipmap_mode = mipmap_mode;
7167         self
7168     }
address_mode_u( mut self, address_mode_u: SamplerAddressMode, ) -> SamplerCreateInfoBuilder<'a>7169     pub fn address_mode_u(
7170         mut self,
7171         address_mode_u: SamplerAddressMode,
7172     ) -> SamplerCreateInfoBuilder<'a> {
7173         self.inner.address_mode_u = address_mode_u;
7174         self
7175     }
address_mode_v( mut self, address_mode_v: SamplerAddressMode, ) -> SamplerCreateInfoBuilder<'a>7176     pub fn address_mode_v(
7177         mut self,
7178         address_mode_v: SamplerAddressMode,
7179     ) -> SamplerCreateInfoBuilder<'a> {
7180         self.inner.address_mode_v = address_mode_v;
7181         self
7182     }
address_mode_w( mut self, address_mode_w: SamplerAddressMode, ) -> SamplerCreateInfoBuilder<'a>7183     pub fn address_mode_w(
7184         mut self,
7185         address_mode_w: SamplerAddressMode,
7186     ) -> SamplerCreateInfoBuilder<'a> {
7187         self.inner.address_mode_w = address_mode_w;
7188         self
7189     }
mip_lod_bias(mut self, mip_lod_bias: f32) -> SamplerCreateInfoBuilder<'a>7190     pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> SamplerCreateInfoBuilder<'a> {
7191         self.inner.mip_lod_bias = mip_lod_bias;
7192         self
7193     }
anisotropy_enable(mut self, anisotropy_enable: bool) -> SamplerCreateInfoBuilder<'a>7194     pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> SamplerCreateInfoBuilder<'a> {
7195         self.inner.anisotropy_enable = anisotropy_enable.into();
7196         self
7197     }
max_anisotropy(mut self, max_anisotropy: f32) -> SamplerCreateInfoBuilder<'a>7198     pub fn max_anisotropy(mut self, max_anisotropy: f32) -> SamplerCreateInfoBuilder<'a> {
7199         self.inner.max_anisotropy = max_anisotropy;
7200         self
7201     }
compare_enable(mut self, compare_enable: bool) -> SamplerCreateInfoBuilder<'a>7202     pub fn compare_enable(mut self, compare_enable: bool) -> SamplerCreateInfoBuilder<'a> {
7203         self.inner.compare_enable = compare_enable.into();
7204         self
7205     }
compare_op(mut self, compare_op: CompareOp) -> SamplerCreateInfoBuilder<'a>7206     pub fn compare_op(mut self, compare_op: CompareOp) -> SamplerCreateInfoBuilder<'a> {
7207         self.inner.compare_op = compare_op;
7208         self
7209     }
min_lod(mut self, min_lod: f32) -> SamplerCreateInfoBuilder<'a>7210     pub fn min_lod(mut self, min_lod: f32) -> SamplerCreateInfoBuilder<'a> {
7211         self.inner.min_lod = min_lod;
7212         self
7213     }
max_lod(mut self, max_lod: f32) -> SamplerCreateInfoBuilder<'a>7214     pub fn max_lod(mut self, max_lod: f32) -> SamplerCreateInfoBuilder<'a> {
7215         self.inner.max_lod = max_lod;
7216         self
7217     }
border_color(mut self, border_color: BorderColor) -> SamplerCreateInfoBuilder<'a>7218     pub fn border_color(mut self, border_color: BorderColor) -> SamplerCreateInfoBuilder<'a> {
7219         self.inner.border_color = border_color;
7220         self
7221     }
unnormalized_coordinates( mut self, unnormalized_coordinates: bool, ) -> SamplerCreateInfoBuilder<'a>7222     pub fn unnormalized_coordinates(
7223         mut self,
7224         unnormalized_coordinates: bool,
7225     ) -> SamplerCreateInfoBuilder<'a> {
7226         self.inner.unnormalized_coordinates = unnormalized_coordinates.into();
7227         self
7228     }
7229     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7230     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7231     #[doc = r" valid extension structs can be pushed into the chain."]
7232     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7233     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSamplerCreateInfo>( mut self, next: &'a mut T, ) -> SamplerCreateInfoBuilder<'a>7234     pub fn push_next<T: ExtendsSamplerCreateInfo>(
7235         mut self,
7236         next: &'a mut T,
7237     ) -> SamplerCreateInfoBuilder<'a> {
7238         unsafe {
7239             let next_ptr = next as *mut T as *mut BaseOutStructure;
7240             let last_next = ptr_chain_iter(next).last().unwrap();
7241             (*last_next).p_next = self.inner.p_next as _;
7242             self.inner.p_next = next_ptr as _;
7243         }
7244         self
7245     }
7246     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7247     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7248     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerCreateInfo7249     pub fn build(self) -> SamplerCreateInfo {
7250         self.inner
7251     }
7252 }
7253 #[repr(C)]
7254 #[derive(Copy, Clone, Debug)]
7255 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateInfo.html>"]
7256 pub struct CommandPoolCreateInfo {
7257     pub s_type: StructureType,
7258     pub p_next: *const c_void,
7259     pub flags: CommandPoolCreateFlags,
7260     pub queue_family_index: u32,
7261 }
7262 impl ::std::default::Default for CommandPoolCreateInfo {
default() -> CommandPoolCreateInfo7263     fn default() -> CommandPoolCreateInfo {
7264         CommandPoolCreateInfo {
7265             s_type: StructureType::COMMAND_POOL_CREATE_INFO,
7266             p_next: ::std::ptr::null(),
7267             flags: CommandPoolCreateFlags::default(),
7268             queue_family_index: u32::default(),
7269         }
7270     }
7271 }
7272 impl CommandPoolCreateInfo {
builder<'a>() -> CommandPoolCreateInfoBuilder<'a>7273     pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> {
7274         CommandPoolCreateInfoBuilder {
7275             inner: CommandPoolCreateInfo::default(),
7276             marker: ::std::marker::PhantomData,
7277         }
7278     }
7279 }
7280 #[repr(transparent)]
7281 pub struct CommandPoolCreateInfoBuilder<'a> {
7282     inner: CommandPoolCreateInfo,
7283     marker: ::std::marker::PhantomData<&'a ()>,
7284 }
7285 pub unsafe trait ExtendsCommandPoolCreateInfo {}
7286 impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> {
7287     type Target = CommandPoolCreateInfo;
deref(&self) -> &Self::Target7288     fn deref(&self) -> &Self::Target {
7289         &self.inner
7290     }
7291 }
7292 impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7293     fn deref_mut(&mut self) -> &mut Self::Target {
7294         &mut self.inner
7295     }
7296 }
7297 impl<'a> CommandPoolCreateInfoBuilder<'a> {
flags(mut self, flags: CommandPoolCreateFlags) -> CommandPoolCreateInfoBuilder<'a>7298     pub fn flags(mut self, flags: CommandPoolCreateFlags) -> CommandPoolCreateInfoBuilder<'a> {
7299         self.inner.flags = flags;
7300         self
7301     }
queue_family_index( mut self, queue_family_index: u32, ) -> CommandPoolCreateInfoBuilder<'a>7302     pub fn queue_family_index(
7303         mut self,
7304         queue_family_index: u32,
7305     ) -> CommandPoolCreateInfoBuilder<'a> {
7306         self.inner.queue_family_index = queue_family_index;
7307         self
7308     }
7309     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7310     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7311     #[doc = r" valid extension structs can be pushed into the chain."]
7312     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7313     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCommandPoolCreateInfo>( mut self, next: &'a mut T, ) -> CommandPoolCreateInfoBuilder<'a>7314     pub fn push_next<T: ExtendsCommandPoolCreateInfo>(
7315         mut self,
7316         next: &'a mut T,
7317     ) -> CommandPoolCreateInfoBuilder<'a> {
7318         unsafe {
7319             let next_ptr = next as *mut T as *mut BaseOutStructure;
7320             let last_next = ptr_chain_iter(next).last().unwrap();
7321             (*last_next).p_next = self.inner.p_next as _;
7322             self.inner.p_next = next_ptr as _;
7323         }
7324         self
7325     }
7326     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7327     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7328     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandPoolCreateInfo7329     pub fn build(self) -> CommandPoolCreateInfo {
7330         self.inner
7331     }
7332 }
7333 #[repr(C)]
7334 #[derive(Copy, Clone, Debug)]
7335 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferAllocateInfo.html>"]
7336 pub struct CommandBufferAllocateInfo {
7337     pub s_type: StructureType,
7338     pub p_next: *const c_void,
7339     pub command_pool: CommandPool,
7340     pub level: CommandBufferLevel,
7341     pub command_buffer_count: u32,
7342 }
7343 impl ::std::default::Default for CommandBufferAllocateInfo {
default() -> CommandBufferAllocateInfo7344     fn default() -> CommandBufferAllocateInfo {
7345         CommandBufferAllocateInfo {
7346             s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO,
7347             p_next: ::std::ptr::null(),
7348             command_pool: CommandPool::default(),
7349             level: CommandBufferLevel::default(),
7350             command_buffer_count: u32::default(),
7351         }
7352     }
7353 }
7354 impl CommandBufferAllocateInfo {
builder<'a>() -> CommandBufferAllocateInfoBuilder<'a>7355     pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> {
7356         CommandBufferAllocateInfoBuilder {
7357             inner: CommandBufferAllocateInfo::default(),
7358             marker: ::std::marker::PhantomData,
7359         }
7360     }
7361 }
7362 #[repr(transparent)]
7363 pub struct CommandBufferAllocateInfoBuilder<'a> {
7364     inner: CommandBufferAllocateInfo,
7365     marker: ::std::marker::PhantomData<&'a ()>,
7366 }
7367 pub unsafe trait ExtendsCommandBufferAllocateInfo {}
7368 impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> {
7369     type Target = CommandBufferAllocateInfo;
deref(&self) -> &Self::Target7370     fn deref(&self) -> &Self::Target {
7371         &self.inner
7372     }
7373 }
7374 impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7375     fn deref_mut(&mut self) -> &mut Self::Target {
7376         &mut self.inner
7377     }
7378 }
7379 impl<'a> CommandBufferAllocateInfoBuilder<'a> {
command_pool( mut self, command_pool: CommandPool, ) -> CommandBufferAllocateInfoBuilder<'a>7380     pub fn command_pool(
7381         mut self,
7382         command_pool: CommandPool,
7383     ) -> CommandBufferAllocateInfoBuilder<'a> {
7384         self.inner.command_pool = command_pool;
7385         self
7386     }
level(mut self, level: CommandBufferLevel) -> CommandBufferAllocateInfoBuilder<'a>7387     pub fn level(mut self, level: CommandBufferLevel) -> CommandBufferAllocateInfoBuilder<'a> {
7388         self.inner.level = level;
7389         self
7390     }
command_buffer_count( mut self, command_buffer_count: u32, ) -> CommandBufferAllocateInfoBuilder<'a>7391     pub fn command_buffer_count(
7392         mut self,
7393         command_buffer_count: u32,
7394     ) -> CommandBufferAllocateInfoBuilder<'a> {
7395         self.inner.command_buffer_count = command_buffer_count;
7396         self
7397     }
7398     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7399     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7400     #[doc = r" valid extension structs can be pushed into the chain."]
7401     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7402     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCommandBufferAllocateInfo>( mut self, next: &'a mut T, ) -> CommandBufferAllocateInfoBuilder<'a>7403     pub fn push_next<T: ExtendsCommandBufferAllocateInfo>(
7404         mut self,
7405         next: &'a mut T,
7406     ) -> CommandBufferAllocateInfoBuilder<'a> {
7407         unsafe {
7408             let next_ptr = next as *mut T as *mut BaseOutStructure;
7409             let last_next = ptr_chain_iter(next).last().unwrap();
7410             (*last_next).p_next = self.inner.p_next as _;
7411             self.inner.p_next = next_ptr as _;
7412         }
7413         self
7414     }
7415     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7416     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7417     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferAllocateInfo7418     pub fn build(self) -> CommandBufferAllocateInfo {
7419         self.inner
7420     }
7421 }
7422 #[repr(C)]
7423 #[derive(Copy, Clone, Debug)]
7424 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceInfo.html>"]
7425 pub struct CommandBufferInheritanceInfo {
7426     pub s_type: StructureType,
7427     pub p_next: *const c_void,
7428     pub render_pass: RenderPass,
7429     pub subpass: u32,
7430     pub framebuffer: Framebuffer,
7431     pub occlusion_query_enable: Bool32,
7432     pub query_flags: QueryControlFlags,
7433     pub pipeline_statistics: QueryPipelineStatisticFlags,
7434 }
7435 impl ::std::default::Default for CommandBufferInheritanceInfo {
default() -> CommandBufferInheritanceInfo7436     fn default() -> CommandBufferInheritanceInfo {
7437         CommandBufferInheritanceInfo {
7438             s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO,
7439             p_next: ::std::ptr::null(),
7440             render_pass: RenderPass::default(),
7441             subpass: u32::default(),
7442             framebuffer: Framebuffer::default(),
7443             occlusion_query_enable: Bool32::default(),
7444             query_flags: QueryControlFlags::default(),
7445             pipeline_statistics: QueryPipelineStatisticFlags::default(),
7446         }
7447     }
7448 }
7449 impl CommandBufferInheritanceInfo {
builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a>7450     pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> {
7451         CommandBufferInheritanceInfoBuilder {
7452             inner: CommandBufferInheritanceInfo::default(),
7453             marker: ::std::marker::PhantomData,
7454         }
7455     }
7456 }
7457 #[repr(transparent)]
7458 pub struct CommandBufferInheritanceInfoBuilder<'a> {
7459     inner: CommandBufferInheritanceInfo,
7460     marker: ::std::marker::PhantomData<&'a ()>,
7461 }
7462 pub unsafe trait ExtendsCommandBufferInheritanceInfo {}
7463 impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> {
7464     type Target = CommandBufferInheritanceInfo;
deref(&self) -> &Self::Target7465     fn deref(&self) -> &Self::Target {
7466         &self.inner
7467     }
7468 }
7469 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7470     fn deref_mut(&mut self) -> &mut Self::Target {
7471         &mut self.inner
7472     }
7473 }
7474 impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
render_pass( mut self, render_pass: RenderPass, ) -> CommandBufferInheritanceInfoBuilder<'a>7475     pub fn render_pass(
7476         mut self,
7477         render_pass: RenderPass,
7478     ) -> CommandBufferInheritanceInfoBuilder<'a> {
7479         self.inner.render_pass = render_pass;
7480         self
7481     }
subpass(mut self, subpass: u32) -> CommandBufferInheritanceInfoBuilder<'a>7482     pub fn subpass(mut self, subpass: u32) -> CommandBufferInheritanceInfoBuilder<'a> {
7483         self.inner.subpass = subpass;
7484         self
7485     }
framebuffer( mut self, framebuffer: Framebuffer, ) -> CommandBufferInheritanceInfoBuilder<'a>7486     pub fn framebuffer(
7487         mut self,
7488         framebuffer: Framebuffer,
7489     ) -> CommandBufferInheritanceInfoBuilder<'a> {
7490         self.inner.framebuffer = framebuffer;
7491         self
7492     }
occlusion_query_enable( mut self, occlusion_query_enable: bool, ) -> CommandBufferInheritanceInfoBuilder<'a>7493     pub fn occlusion_query_enable(
7494         mut self,
7495         occlusion_query_enable: bool,
7496     ) -> CommandBufferInheritanceInfoBuilder<'a> {
7497         self.inner.occlusion_query_enable = occlusion_query_enable.into();
7498         self
7499     }
query_flags( mut self, query_flags: QueryControlFlags, ) -> CommandBufferInheritanceInfoBuilder<'a>7500     pub fn query_flags(
7501         mut self,
7502         query_flags: QueryControlFlags,
7503     ) -> CommandBufferInheritanceInfoBuilder<'a> {
7504         self.inner.query_flags = query_flags;
7505         self
7506     }
pipeline_statistics( mut self, pipeline_statistics: QueryPipelineStatisticFlags, ) -> CommandBufferInheritanceInfoBuilder<'a>7507     pub fn pipeline_statistics(
7508         mut self,
7509         pipeline_statistics: QueryPipelineStatisticFlags,
7510     ) -> CommandBufferInheritanceInfoBuilder<'a> {
7511         self.inner.pipeline_statistics = pipeline_statistics;
7512         self
7513     }
7514     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7515     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7516     #[doc = r" valid extension structs can be pushed into the chain."]
7517     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7518     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCommandBufferInheritanceInfo>( mut self, next: &'a mut T, ) -> CommandBufferInheritanceInfoBuilder<'a>7519     pub fn push_next<T: ExtendsCommandBufferInheritanceInfo>(
7520         mut self,
7521         next: &'a mut T,
7522     ) -> CommandBufferInheritanceInfoBuilder<'a> {
7523         unsafe {
7524             let next_ptr = next as *mut T as *mut BaseOutStructure;
7525             let last_next = ptr_chain_iter(next).last().unwrap();
7526             (*last_next).p_next = self.inner.p_next as _;
7527             self.inner.p_next = next_ptr as _;
7528         }
7529         self
7530     }
7531     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7532     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7533     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceInfo7534     pub fn build(self) -> CommandBufferInheritanceInfo {
7535         self.inner
7536     }
7537 }
7538 #[repr(C)]
7539 #[derive(Copy, Clone, Debug)]
7540 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferBeginInfo.html>"]
7541 pub struct CommandBufferBeginInfo {
7542     pub s_type: StructureType,
7543     pub p_next: *const c_void,
7544     pub flags: CommandBufferUsageFlags,
7545     pub p_inheritance_info: *const CommandBufferInheritanceInfo,
7546 }
7547 impl ::std::default::Default for CommandBufferBeginInfo {
default() -> CommandBufferBeginInfo7548     fn default() -> CommandBufferBeginInfo {
7549         CommandBufferBeginInfo {
7550             s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO,
7551             p_next: ::std::ptr::null(),
7552             flags: CommandBufferUsageFlags::default(),
7553             p_inheritance_info: ::std::ptr::null(),
7554         }
7555     }
7556 }
7557 impl CommandBufferBeginInfo {
builder<'a>() -> CommandBufferBeginInfoBuilder<'a>7558     pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> {
7559         CommandBufferBeginInfoBuilder {
7560             inner: CommandBufferBeginInfo::default(),
7561             marker: ::std::marker::PhantomData,
7562         }
7563     }
7564 }
7565 #[repr(transparent)]
7566 pub struct CommandBufferBeginInfoBuilder<'a> {
7567     inner: CommandBufferBeginInfo,
7568     marker: ::std::marker::PhantomData<&'a ()>,
7569 }
7570 pub unsafe trait ExtendsCommandBufferBeginInfo {}
7571 impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> {
7572     type Target = CommandBufferBeginInfo;
deref(&self) -> &Self::Target7573     fn deref(&self) -> &Self::Target {
7574         &self.inner
7575     }
7576 }
7577 impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7578     fn deref_mut(&mut self) -> &mut Self::Target {
7579         &mut self.inner
7580     }
7581 }
7582 impl<'a> CommandBufferBeginInfoBuilder<'a> {
flags(mut self, flags: CommandBufferUsageFlags) -> CommandBufferBeginInfoBuilder<'a>7583     pub fn flags(mut self, flags: CommandBufferUsageFlags) -> CommandBufferBeginInfoBuilder<'a> {
7584         self.inner.flags = flags;
7585         self
7586     }
inheritance_info( mut self, inheritance_info: &'a CommandBufferInheritanceInfo, ) -> CommandBufferBeginInfoBuilder<'a>7587     pub fn inheritance_info(
7588         mut self,
7589         inheritance_info: &'a CommandBufferInheritanceInfo,
7590     ) -> CommandBufferBeginInfoBuilder<'a> {
7591         self.inner.p_inheritance_info = inheritance_info;
7592         self
7593     }
7594     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7595     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7596     #[doc = r" valid extension structs can be pushed into the chain."]
7597     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7598     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCommandBufferBeginInfo>( mut self, next: &'a mut T, ) -> CommandBufferBeginInfoBuilder<'a>7599     pub fn push_next<T: ExtendsCommandBufferBeginInfo>(
7600         mut self,
7601         next: &'a mut T,
7602     ) -> CommandBufferBeginInfoBuilder<'a> {
7603         unsafe {
7604             let next_ptr = next as *mut T as *mut BaseOutStructure;
7605             let last_next = ptr_chain_iter(next).last().unwrap();
7606             (*last_next).p_next = self.inner.p_next as _;
7607             self.inner.p_next = next_ptr as _;
7608         }
7609         self
7610     }
7611     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7612     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7613     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferBeginInfo7614     pub fn build(self) -> CommandBufferBeginInfo {
7615         self.inner
7616     }
7617 }
7618 #[repr(C)]
7619 #[derive(Copy, Clone)]
7620 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassBeginInfo.html>"]
7621 pub struct RenderPassBeginInfo {
7622     pub s_type: StructureType,
7623     pub p_next: *const c_void,
7624     pub render_pass: RenderPass,
7625     pub framebuffer: Framebuffer,
7626     pub render_area: Rect2D,
7627     pub clear_value_count: u32,
7628     pub p_clear_values: *const ClearValue,
7629 }
7630 impl fmt::Debug for RenderPassBeginInfo {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result7631     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
7632         fmt.debug_struct("RenderPassBeginInfo")
7633             .field("s_type", &self.s_type)
7634             .field("p_next", &self.p_next)
7635             .field("render_pass", &self.render_pass)
7636             .field("framebuffer", &self.framebuffer)
7637             .field("render_area", &self.render_area)
7638             .field("clear_value_count", &self.clear_value_count)
7639             .field("p_clear_values", &"union")
7640             .finish()
7641     }
7642 }
7643 impl ::std::default::Default for RenderPassBeginInfo {
default() -> RenderPassBeginInfo7644     fn default() -> RenderPassBeginInfo {
7645         RenderPassBeginInfo {
7646             s_type: StructureType::RENDER_PASS_BEGIN_INFO,
7647             p_next: ::std::ptr::null(),
7648             render_pass: RenderPass::default(),
7649             framebuffer: Framebuffer::default(),
7650             render_area: Rect2D::default(),
7651             clear_value_count: u32::default(),
7652             p_clear_values: ::std::ptr::null(),
7653         }
7654     }
7655 }
7656 impl RenderPassBeginInfo {
builder<'a>() -> RenderPassBeginInfoBuilder<'a>7657     pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> {
7658         RenderPassBeginInfoBuilder {
7659             inner: RenderPassBeginInfo::default(),
7660             marker: ::std::marker::PhantomData,
7661         }
7662     }
7663 }
7664 #[repr(transparent)]
7665 pub struct RenderPassBeginInfoBuilder<'a> {
7666     inner: RenderPassBeginInfo,
7667     marker: ::std::marker::PhantomData<&'a ()>,
7668 }
7669 pub unsafe trait ExtendsRenderPassBeginInfo {}
7670 impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> {
7671     type Target = RenderPassBeginInfo;
deref(&self) -> &Self::Target7672     fn deref(&self) -> &Self::Target {
7673         &self.inner
7674     }
7675 }
7676 impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7677     fn deref_mut(&mut self) -> &mut Self::Target {
7678         &mut self.inner
7679     }
7680 }
7681 impl<'a> RenderPassBeginInfoBuilder<'a> {
render_pass(mut self, render_pass: RenderPass) -> RenderPassBeginInfoBuilder<'a>7682     pub fn render_pass(mut self, render_pass: RenderPass) -> RenderPassBeginInfoBuilder<'a> {
7683         self.inner.render_pass = render_pass;
7684         self
7685     }
framebuffer(mut self, framebuffer: Framebuffer) -> RenderPassBeginInfoBuilder<'a>7686     pub fn framebuffer(mut self, framebuffer: Framebuffer) -> RenderPassBeginInfoBuilder<'a> {
7687         self.inner.framebuffer = framebuffer;
7688         self
7689     }
render_area(mut self, render_area: Rect2D) -> RenderPassBeginInfoBuilder<'a>7690     pub fn render_area(mut self, render_area: Rect2D) -> RenderPassBeginInfoBuilder<'a> {
7691         self.inner.render_area = render_area;
7692         self
7693     }
clear_values( mut self, clear_values: &'a [ClearValue], ) -> RenderPassBeginInfoBuilder<'a>7694     pub fn clear_values(
7695         mut self,
7696         clear_values: &'a [ClearValue],
7697     ) -> RenderPassBeginInfoBuilder<'a> {
7698         self.inner.clear_value_count = clear_values.len() as _;
7699         self.inner.p_clear_values = clear_values.as_ptr();
7700         self
7701     }
7702     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
7703     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
7704     #[doc = r" valid extension structs can be pushed into the chain."]
7705     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
7706     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRenderPassBeginInfo>( mut self, next: &'a mut T, ) -> RenderPassBeginInfoBuilder<'a>7707     pub fn push_next<T: ExtendsRenderPassBeginInfo>(
7708         mut self,
7709         next: &'a mut T,
7710     ) -> RenderPassBeginInfoBuilder<'a> {
7711         unsafe {
7712             let next_ptr = next as *mut T as *mut BaseOutStructure;
7713             let last_next = ptr_chain_iter(next).last().unwrap();
7714             (*last_next).p_next = self.inner.p_next as _;
7715             self.inner.p_next = next_ptr as _;
7716         }
7717         self
7718     }
7719     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7720     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7721     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassBeginInfo7722     pub fn build(self) -> RenderPassBeginInfo {
7723         self.inner
7724     }
7725 }
7726 #[repr(C)]
7727 #[derive(Copy, Clone)]
7728 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearColorValue.html>"]
7729 pub union ClearColorValue {
7730     pub float32: [f32; 4],
7731     pub int32: [i32; 4],
7732     pub uint32: [u32; 4],
7733 }
7734 impl ::std::default::Default for ClearColorValue {
default() -> ClearColorValue7735     fn default() -> ClearColorValue {
7736         unsafe { ::std::mem::zeroed() }
7737     }
7738 }
7739 #[repr(C)]
7740 #[derive(Copy, Clone, Default, Debug)]
7741 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearDepthStencilValue.html>"]
7742 pub struct ClearDepthStencilValue {
7743     pub depth: f32,
7744     pub stencil: u32,
7745 }
7746 impl ClearDepthStencilValue {
builder<'a>() -> ClearDepthStencilValueBuilder<'a>7747     pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> {
7748         ClearDepthStencilValueBuilder {
7749             inner: ClearDepthStencilValue::default(),
7750             marker: ::std::marker::PhantomData,
7751         }
7752     }
7753 }
7754 #[repr(transparent)]
7755 pub struct ClearDepthStencilValueBuilder<'a> {
7756     inner: ClearDepthStencilValue,
7757     marker: ::std::marker::PhantomData<&'a ()>,
7758 }
7759 impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> {
7760     type Target = ClearDepthStencilValue;
deref(&self) -> &Self::Target7761     fn deref(&self) -> &Self::Target {
7762         &self.inner
7763     }
7764 }
7765 impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7766     fn deref_mut(&mut self) -> &mut Self::Target {
7767         &mut self.inner
7768     }
7769 }
7770 impl<'a> ClearDepthStencilValueBuilder<'a> {
depth(mut self, depth: f32) -> ClearDepthStencilValueBuilder<'a>7771     pub fn depth(mut self, depth: f32) -> ClearDepthStencilValueBuilder<'a> {
7772         self.inner.depth = depth;
7773         self
7774     }
stencil(mut self, stencil: u32) -> ClearDepthStencilValueBuilder<'a>7775     pub fn stencil(mut self, stencil: u32) -> ClearDepthStencilValueBuilder<'a> {
7776         self.inner.stencil = stencil;
7777         self
7778     }
7779     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7780     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7781     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ClearDepthStencilValue7782     pub fn build(self) -> ClearDepthStencilValue {
7783         self.inner
7784     }
7785 }
7786 #[repr(C)]
7787 #[derive(Copy, Clone)]
7788 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearValue.html>"]
7789 pub union ClearValue {
7790     pub color: ClearColorValue,
7791     pub depth_stencil: ClearDepthStencilValue,
7792 }
7793 impl ::std::default::Default for ClearValue {
default() -> ClearValue7794     fn default() -> ClearValue {
7795         unsafe { ::std::mem::zeroed() }
7796     }
7797 }
7798 #[repr(C)]
7799 #[derive(Copy, Clone, Default)]
7800 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearAttachment.html>"]
7801 pub struct ClearAttachment {
7802     pub aspect_mask: ImageAspectFlags,
7803     pub color_attachment: u32,
7804     pub clear_value: ClearValue,
7805 }
7806 impl fmt::Debug for ClearAttachment {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result7807     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
7808         fmt.debug_struct("ClearAttachment")
7809             .field("aspect_mask", &self.aspect_mask)
7810             .field("color_attachment", &self.color_attachment)
7811             .field("clear_value", &"union")
7812             .finish()
7813     }
7814 }
7815 impl ClearAttachment {
builder<'a>() -> ClearAttachmentBuilder<'a>7816     pub fn builder<'a>() -> ClearAttachmentBuilder<'a> {
7817         ClearAttachmentBuilder {
7818             inner: ClearAttachment::default(),
7819             marker: ::std::marker::PhantomData,
7820         }
7821     }
7822 }
7823 #[repr(transparent)]
7824 pub struct ClearAttachmentBuilder<'a> {
7825     inner: ClearAttachment,
7826     marker: ::std::marker::PhantomData<&'a ()>,
7827 }
7828 impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> {
7829     type Target = ClearAttachment;
deref(&self) -> &Self::Target7830     fn deref(&self) -> &Self::Target {
7831         &self.inner
7832     }
7833 }
7834 impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7835     fn deref_mut(&mut self) -> &mut Self::Target {
7836         &mut self.inner
7837     }
7838 }
7839 impl<'a> ClearAttachmentBuilder<'a> {
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ClearAttachmentBuilder<'a>7840     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ClearAttachmentBuilder<'a> {
7841         self.inner.aspect_mask = aspect_mask;
7842         self
7843     }
color_attachment(mut self, color_attachment: u32) -> ClearAttachmentBuilder<'a>7844     pub fn color_attachment(mut self, color_attachment: u32) -> ClearAttachmentBuilder<'a> {
7845         self.inner.color_attachment = color_attachment;
7846         self
7847     }
clear_value(mut self, clear_value: ClearValue) -> ClearAttachmentBuilder<'a>7848     pub fn clear_value(mut self, clear_value: ClearValue) -> ClearAttachmentBuilder<'a> {
7849         self.inner.clear_value = clear_value;
7850         self
7851     }
7852     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7853     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7854     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ClearAttachment7855     pub fn build(self) -> ClearAttachment {
7856         self.inner
7857     }
7858 }
7859 #[repr(C)]
7860 #[derive(Copy, Clone, Default, Debug)]
7861 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescription.html>"]
7862 pub struct AttachmentDescription {
7863     pub flags: AttachmentDescriptionFlags,
7864     pub format: Format,
7865     pub samples: SampleCountFlags,
7866     pub load_op: AttachmentLoadOp,
7867     pub store_op: AttachmentStoreOp,
7868     pub stencil_load_op: AttachmentLoadOp,
7869     pub stencil_store_op: AttachmentStoreOp,
7870     pub initial_layout: ImageLayout,
7871     pub final_layout: ImageLayout,
7872 }
7873 impl AttachmentDescription {
builder<'a>() -> AttachmentDescriptionBuilder<'a>7874     pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> {
7875         AttachmentDescriptionBuilder {
7876             inner: AttachmentDescription::default(),
7877             marker: ::std::marker::PhantomData,
7878         }
7879     }
7880 }
7881 #[repr(transparent)]
7882 pub struct AttachmentDescriptionBuilder<'a> {
7883     inner: AttachmentDescription,
7884     marker: ::std::marker::PhantomData<&'a ()>,
7885 }
7886 impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> {
7887     type Target = AttachmentDescription;
deref(&self) -> &Self::Target7888     fn deref(&self) -> &Self::Target {
7889         &self.inner
7890     }
7891 }
7892 impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7893     fn deref_mut(&mut self) -> &mut Self::Target {
7894         &mut self.inner
7895     }
7896 }
7897 impl<'a> AttachmentDescriptionBuilder<'a> {
flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescriptionBuilder<'a>7898     pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescriptionBuilder<'a> {
7899         self.inner.flags = flags;
7900         self
7901     }
format(mut self, format: Format) -> AttachmentDescriptionBuilder<'a>7902     pub fn format(mut self, format: Format) -> AttachmentDescriptionBuilder<'a> {
7903         self.inner.format = format;
7904         self
7905     }
samples(mut self, samples: SampleCountFlags) -> AttachmentDescriptionBuilder<'a>7906     pub fn samples(mut self, samples: SampleCountFlags) -> AttachmentDescriptionBuilder<'a> {
7907         self.inner.samples = samples;
7908         self
7909     }
load_op(mut self, load_op: AttachmentLoadOp) -> AttachmentDescriptionBuilder<'a>7910     pub fn load_op(mut self, load_op: AttachmentLoadOp) -> AttachmentDescriptionBuilder<'a> {
7911         self.inner.load_op = load_op;
7912         self
7913     }
store_op(mut self, store_op: AttachmentStoreOp) -> AttachmentDescriptionBuilder<'a>7914     pub fn store_op(mut self, store_op: AttachmentStoreOp) -> AttachmentDescriptionBuilder<'a> {
7915         self.inner.store_op = store_op;
7916         self
7917     }
stencil_load_op( mut self, stencil_load_op: AttachmentLoadOp, ) -> AttachmentDescriptionBuilder<'a>7918     pub fn stencil_load_op(
7919         mut self,
7920         stencil_load_op: AttachmentLoadOp,
7921     ) -> AttachmentDescriptionBuilder<'a> {
7922         self.inner.stencil_load_op = stencil_load_op;
7923         self
7924     }
stencil_store_op( mut self, stencil_store_op: AttachmentStoreOp, ) -> AttachmentDescriptionBuilder<'a>7925     pub fn stencil_store_op(
7926         mut self,
7927         stencil_store_op: AttachmentStoreOp,
7928     ) -> AttachmentDescriptionBuilder<'a> {
7929         self.inner.stencil_store_op = stencil_store_op;
7930         self
7931     }
initial_layout( mut self, initial_layout: ImageLayout, ) -> AttachmentDescriptionBuilder<'a>7932     pub fn initial_layout(
7933         mut self,
7934         initial_layout: ImageLayout,
7935     ) -> AttachmentDescriptionBuilder<'a> {
7936         self.inner.initial_layout = initial_layout;
7937         self
7938     }
final_layout(mut self, final_layout: ImageLayout) -> AttachmentDescriptionBuilder<'a>7939     pub fn final_layout(mut self, final_layout: ImageLayout) -> AttachmentDescriptionBuilder<'a> {
7940         self.inner.final_layout = final_layout;
7941         self
7942     }
7943     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7944     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7945     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentDescription7946     pub fn build(self) -> AttachmentDescription {
7947         self.inner
7948     }
7949 }
7950 #[repr(C)]
7951 #[derive(Copy, Clone, Default, Debug)]
7952 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReference.html>"]
7953 pub struct AttachmentReference {
7954     pub attachment: u32,
7955     pub layout: ImageLayout,
7956 }
7957 impl AttachmentReference {
builder<'a>() -> AttachmentReferenceBuilder<'a>7958     pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> {
7959         AttachmentReferenceBuilder {
7960             inner: AttachmentReference::default(),
7961             marker: ::std::marker::PhantomData,
7962         }
7963     }
7964 }
7965 #[repr(transparent)]
7966 pub struct AttachmentReferenceBuilder<'a> {
7967     inner: AttachmentReference,
7968     marker: ::std::marker::PhantomData<&'a ()>,
7969 }
7970 impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> {
7971     type Target = AttachmentReference;
deref(&self) -> &Self::Target7972     fn deref(&self) -> &Self::Target {
7973         &self.inner
7974     }
7975 }
7976 impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target7977     fn deref_mut(&mut self) -> &mut Self::Target {
7978         &mut self.inner
7979     }
7980 }
7981 impl<'a> AttachmentReferenceBuilder<'a> {
attachment(mut self, attachment: u32) -> AttachmentReferenceBuilder<'a>7982     pub fn attachment(mut self, attachment: u32) -> AttachmentReferenceBuilder<'a> {
7983         self.inner.attachment = attachment;
7984         self
7985     }
layout(mut self, layout: ImageLayout) -> AttachmentReferenceBuilder<'a>7986     pub fn layout(mut self, layout: ImageLayout) -> AttachmentReferenceBuilder<'a> {
7987         self.inner.layout = layout;
7988         self
7989     }
7990     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
7991     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
7992     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentReference7993     pub fn build(self) -> AttachmentReference {
7994         self.inner
7995     }
7996 }
7997 #[repr(C)]
7998 #[derive(Copy, Clone, Debug)]
7999 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescription.html>"]
8000 pub struct SubpassDescription {
8001     pub flags: SubpassDescriptionFlags,
8002     pub pipeline_bind_point: PipelineBindPoint,
8003     pub input_attachment_count: u32,
8004     pub p_input_attachments: *const AttachmentReference,
8005     pub color_attachment_count: u32,
8006     pub p_color_attachments: *const AttachmentReference,
8007     pub p_resolve_attachments: *const AttachmentReference,
8008     pub p_depth_stencil_attachment: *const AttachmentReference,
8009     pub preserve_attachment_count: u32,
8010     pub p_preserve_attachments: *const u32,
8011 }
8012 impl ::std::default::Default for SubpassDescription {
default() -> SubpassDescription8013     fn default() -> SubpassDescription {
8014         SubpassDescription {
8015             flags: SubpassDescriptionFlags::default(),
8016             pipeline_bind_point: PipelineBindPoint::default(),
8017             input_attachment_count: u32::default(),
8018             p_input_attachments: ::std::ptr::null(),
8019             color_attachment_count: u32::default(),
8020             p_color_attachments: ::std::ptr::null(),
8021             p_resolve_attachments: ::std::ptr::null(),
8022             p_depth_stencil_attachment: ::std::ptr::null(),
8023             preserve_attachment_count: u32::default(),
8024             p_preserve_attachments: ::std::ptr::null(),
8025         }
8026     }
8027 }
8028 impl SubpassDescription {
builder<'a>() -> SubpassDescriptionBuilder<'a>8029     pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> {
8030         SubpassDescriptionBuilder {
8031             inner: SubpassDescription::default(),
8032             marker: ::std::marker::PhantomData,
8033         }
8034     }
8035 }
8036 #[repr(transparent)]
8037 pub struct SubpassDescriptionBuilder<'a> {
8038     inner: SubpassDescription,
8039     marker: ::std::marker::PhantomData<&'a ()>,
8040 }
8041 impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> {
8042     type Target = SubpassDescription;
deref(&self) -> &Self::Target8043     fn deref(&self) -> &Self::Target {
8044         &self.inner
8045     }
8046 }
8047 impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8048     fn deref_mut(&mut self) -> &mut Self::Target {
8049         &mut self.inner
8050     }
8051 }
8052 impl<'a> SubpassDescriptionBuilder<'a> {
flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescriptionBuilder<'a>8053     pub fn flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescriptionBuilder<'a> {
8054         self.inner.flags = flags;
8055         self
8056     }
pipeline_bind_point( mut self, pipeline_bind_point: PipelineBindPoint, ) -> SubpassDescriptionBuilder<'a>8057     pub fn pipeline_bind_point(
8058         mut self,
8059         pipeline_bind_point: PipelineBindPoint,
8060     ) -> SubpassDescriptionBuilder<'a> {
8061         self.inner.pipeline_bind_point = pipeline_bind_point;
8062         self
8063     }
input_attachments( mut self, input_attachments: &'a [AttachmentReference], ) -> SubpassDescriptionBuilder<'a>8064     pub fn input_attachments(
8065         mut self,
8066         input_attachments: &'a [AttachmentReference],
8067     ) -> SubpassDescriptionBuilder<'a> {
8068         self.inner.input_attachment_count = input_attachments.len() as _;
8069         self.inner.p_input_attachments = input_attachments.as_ptr();
8070         self
8071     }
color_attachments( mut self, color_attachments: &'a [AttachmentReference], ) -> SubpassDescriptionBuilder<'a>8072     pub fn color_attachments(
8073         mut self,
8074         color_attachments: &'a [AttachmentReference],
8075     ) -> SubpassDescriptionBuilder<'a> {
8076         self.inner.color_attachment_count = color_attachments.len() as _;
8077         self.inner.p_color_attachments = color_attachments.as_ptr();
8078         self
8079     }
resolve_attachments( mut self, resolve_attachments: &'a [AttachmentReference], ) -> SubpassDescriptionBuilder<'a>8080     pub fn resolve_attachments(
8081         mut self,
8082         resolve_attachments: &'a [AttachmentReference],
8083     ) -> SubpassDescriptionBuilder<'a> {
8084         self.inner.color_attachment_count = resolve_attachments.len() as _;
8085         self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
8086         self
8087     }
depth_stencil_attachment( mut self, depth_stencil_attachment: &'a AttachmentReference, ) -> SubpassDescriptionBuilder<'a>8088     pub fn depth_stencil_attachment(
8089         mut self,
8090         depth_stencil_attachment: &'a AttachmentReference,
8091     ) -> SubpassDescriptionBuilder<'a> {
8092         self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
8093         self
8094     }
preserve_attachments( mut self, preserve_attachments: &'a [u32], ) -> SubpassDescriptionBuilder<'a>8095     pub fn preserve_attachments(
8096         mut self,
8097         preserve_attachments: &'a [u32],
8098     ) -> SubpassDescriptionBuilder<'a> {
8099         self.inner.preserve_attachment_count = preserve_attachments.len() as _;
8100         self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
8101         self
8102     }
8103     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8104     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8105     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDescription8106     pub fn build(self) -> SubpassDescription {
8107         self.inner
8108     }
8109 }
8110 #[repr(C)]
8111 #[derive(Copy, Clone, Default, Debug)]
8112 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDependency.html>"]
8113 pub struct SubpassDependency {
8114     pub src_subpass: u32,
8115     pub dst_subpass: u32,
8116     pub src_stage_mask: PipelineStageFlags,
8117     pub dst_stage_mask: PipelineStageFlags,
8118     pub src_access_mask: AccessFlags,
8119     pub dst_access_mask: AccessFlags,
8120     pub dependency_flags: DependencyFlags,
8121 }
8122 impl SubpassDependency {
builder<'a>() -> SubpassDependencyBuilder<'a>8123     pub fn builder<'a>() -> SubpassDependencyBuilder<'a> {
8124         SubpassDependencyBuilder {
8125             inner: SubpassDependency::default(),
8126             marker: ::std::marker::PhantomData,
8127         }
8128     }
8129 }
8130 #[repr(transparent)]
8131 pub struct SubpassDependencyBuilder<'a> {
8132     inner: SubpassDependency,
8133     marker: ::std::marker::PhantomData<&'a ()>,
8134 }
8135 impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> {
8136     type Target = SubpassDependency;
deref(&self) -> &Self::Target8137     fn deref(&self) -> &Self::Target {
8138         &self.inner
8139     }
8140 }
8141 impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8142     fn deref_mut(&mut self) -> &mut Self::Target {
8143         &mut self.inner
8144     }
8145 }
8146 impl<'a> SubpassDependencyBuilder<'a> {
src_subpass(mut self, src_subpass: u32) -> SubpassDependencyBuilder<'a>8147     pub fn src_subpass(mut self, src_subpass: u32) -> SubpassDependencyBuilder<'a> {
8148         self.inner.src_subpass = src_subpass;
8149         self
8150     }
dst_subpass(mut self, dst_subpass: u32) -> SubpassDependencyBuilder<'a>8151     pub fn dst_subpass(mut self, dst_subpass: u32) -> SubpassDependencyBuilder<'a> {
8152         self.inner.dst_subpass = dst_subpass;
8153         self
8154     }
src_stage_mask( mut self, src_stage_mask: PipelineStageFlags, ) -> SubpassDependencyBuilder<'a>8155     pub fn src_stage_mask(
8156         mut self,
8157         src_stage_mask: PipelineStageFlags,
8158     ) -> SubpassDependencyBuilder<'a> {
8159         self.inner.src_stage_mask = src_stage_mask;
8160         self
8161     }
dst_stage_mask( mut self, dst_stage_mask: PipelineStageFlags, ) -> SubpassDependencyBuilder<'a>8162     pub fn dst_stage_mask(
8163         mut self,
8164         dst_stage_mask: PipelineStageFlags,
8165     ) -> SubpassDependencyBuilder<'a> {
8166         self.inner.dst_stage_mask = dst_stage_mask;
8167         self
8168     }
src_access_mask(mut self, src_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a>8169     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a> {
8170         self.inner.src_access_mask = src_access_mask;
8171         self
8172     }
dst_access_mask(mut self, dst_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a>8173     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a> {
8174         self.inner.dst_access_mask = dst_access_mask;
8175         self
8176     }
dependency_flags( mut self, dependency_flags: DependencyFlags, ) -> SubpassDependencyBuilder<'a>8177     pub fn dependency_flags(
8178         mut self,
8179         dependency_flags: DependencyFlags,
8180     ) -> SubpassDependencyBuilder<'a> {
8181         self.inner.dependency_flags = dependency_flags;
8182         self
8183     }
8184     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8185     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8186     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDependency8187     pub fn build(self) -> SubpassDependency {
8188         self.inner
8189     }
8190 }
8191 #[repr(C)]
8192 #[derive(Copy, Clone, Debug)]
8193 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateInfo.html>"]
8194 pub struct RenderPassCreateInfo {
8195     pub s_type: StructureType,
8196     pub p_next: *const c_void,
8197     pub flags: RenderPassCreateFlags,
8198     pub attachment_count: u32,
8199     pub p_attachments: *const AttachmentDescription,
8200     pub subpass_count: u32,
8201     pub p_subpasses: *const SubpassDescription,
8202     pub dependency_count: u32,
8203     pub p_dependencies: *const SubpassDependency,
8204 }
8205 impl ::std::default::Default for RenderPassCreateInfo {
default() -> RenderPassCreateInfo8206     fn default() -> RenderPassCreateInfo {
8207         RenderPassCreateInfo {
8208             s_type: StructureType::RENDER_PASS_CREATE_INFO,
8209             p_next: ::std::ptr::null(),
8210             flags: RenderPassCreateFlags::default(),
8211             attachment_count: u32::default(),
8212             p_attachments: ::std::ptr::null(),
8213             subpass_count: u32::default(),
8214             p_subpasses: ::std::ptr::null(),
8215             dependency_count: u32::default(),
8216             p_dependencies: ::std::ptr::null(),
8217         }
8218     }
8219 }
8220 impl RenderPassCreateInfo {
builder<'a>() -> RenderPassCreateInfoBuilder<'a>8221     pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> {
8222         RenderPassCreateInfoBuilder {
8223             inner: RenderPassCreateInfo::default(),
8224             marker: ::std::marker::PhantomData,
8225         }
8226     }
8227 }
8228 #[repr(transparent)]
8229 pub struct RenderPassCreateInfoBuilder<'a> {
8230     inner: RenderPassCreateInfo,
8231     marker: ::std::marker::PhantomData<&'a ()>,
8232 }
8233 pub unsafe trait ExtendsRenderPassCreateInfo {}
8234 impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> {
8235     type Target = RenderPassCreateInfo;
deref(&self) -> &Self::Target8236     fn deref(&self) -> &Self::Target {
8237         &self.inner
8238     }
8239 }
8240 impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8241     fn deref_mut(&mut self) -> &mut Self::Target {
8242         &mut self.inner
8243     }
8244 }
8245 impl<'a> RenderPassCreateInfoBuilder<'a> {
flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfoBuilder<'a>8246     pub fn flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfoBuilder<'a> {
8247         self.inner.flags = flags;
8248         self
8249     }
attachments( mut self, attachments: &'a [AttachmentDescription], ) -> RenderPassCreateInfoBuilder<'a>8250     pub fn attachments(
8251         mut self,
8252         attachments: &'a [AttachmentDescription],
8253     ) -> RenderPassCreateInfoBuilder<'a> {
8254         self.inner.attachment_count = attachments.len() as _;
8255         self.inner.p_attachments = attachments.as_ptr();
8256         self
8257     }
subpasses( mut self, subpasses: &'a [SubpassDescription], ) -> RenderPassCreateInfoBuilder<'a>8258     pub fn subpasses(
8259         mut self,
8260         subpasses: &'a [SubpassDescription],
8261     ) -> RenderPassCreateInfoBuilder<'a> {
8262         self.inner.subpass_count = subpasses.len() as _;
8263         self.inner.p_subpasses = subpasses.as_ptr();
8264         self
8265     }
dependencies( mut self, dependencies: &'a [SubpassDependency], ) -> RenderPassCreateInfoBuilder<'a>8266     pub fn dependencies(
8267         mut self,
8268         dependencies: &'a [SubpassDependency],
8269     ) -> RenderPassCreateInfoBuilder<'a> {
8270         self.inner.dependency_count = dependencies.len() as _;
8271         self.inner.p_dependencies = dependencies.as_ptr();
8272         self
8273     }
8274     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
8275     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
8276     #[doc = r" valid extension structs can be pushed into the chain."]
8277     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
8278     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRenderPassCreateInfo>( mut self, next: &'a mut T, ) -> RenderPassCreateInfoBuilder<'a>8279     pub fn push_next<T: ExtendsRenderPassCreateInfo>(
8280         mut self,
8281         next: &'a mut T,
8282     ) -> RenderPassCreateInfoBuilder<'a> {
8283         unsafe {
8284             let next_ptr = next as *mut T as *mut BaseOutStructure;
8285             let last_next = ptr_chain_iter(next).last().unwrap();
8286             (*last_next).p_next = self.inner.p_next as _;
8287             self.inner.p_next = next_ptr as _;
8288         }
8289         self
8290     }
8291     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8292     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8293     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassCreateInfo8294     pub fn build(self) -> RenderPassCreateInfo {
8295         self.inner
8296     }
8297 }
8298 #[repr(C)]
8299 #[derive(Copy, Clone, Debug)]
8300 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateInfo.html>"]
8301 pub struct EventCreateInfo {
8302     pub s_type: StructureType,
8303     pub p_next: *const c_void,
8304     pub flags: EventCreateFlags,
8305 }
8306 impl ::std::default::Default for EventCreateInfo {
default() -> EventCreateInfo8307     fn default() -> EventCreateInfo {
8308         EventCreateInfo {
8309             s_type: StructureType::EVENT_CREATE_INFO,
8310             p_next: ::std::ptr::null(),
8311             flags: EventCreateFlags::default(),
8312         }
8313     }
8314 }
8315 impl EventCreateInfo {
builder<'a>() -> EventCreateInfoBuilder<'a>8316     pub fn builder<'a>() -> EventCreateInfoBuilder<'a> {
8317         EventCreateInfoBuilder {
8318             inner: EventCreateInfo::default(),
8319             marker: ::std::marker::PhantomData,
8320         }
8321     }
8322 }
8323 #[repr(transparent)]
8324 pub struct EventCreateInfoBuilder<'a> {
8325     inner: EventCreateInfo,
8326     marker: ::std::marker::PhantomData<&'a ()>,
8327 }
8328 pub unsafe trait ExtendsEventCreateInfo {}
8329 impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> {
8330     type Target = EventCreateInfo;
deref(&self) -> &Self::Target8331     fn deref(&self) -> &Self::Target {
8332         &self.inner
8333     }
8334 }
8335 impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8336     fn deref_mut(&mut self) -> &mut Self::Target {
8337         &mut self.inner
8338     }
8339 }
8340 impl<'a> EventCreateInfoBuilder<'a> {
flags(mut self, flags: EventCreateFlags) -> EventCreateInfoBuilder<'a>8341     pub fn flags(mut self, flags: EventCreateFlags) -> EventCreateInfoBuilder<'a> {
8342         self.inner.flags = flags;
8343         self
8344     }
8345     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
8346     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
8347     #[doc = r" valid extension structs can be pushed into the chain."]
8348     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
8349     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsEventCreateInfo>( mut self, next: &'a mut T, ) -> EventCreateInfoBuilder<'a>8350     pub fn push_next<T: ExtendsEventCreateInfo>(
8351         mut self,
8352         next: &'a mut T,
8353     ) -> EventCreateInfoBuilder<'a> {
8354         unsafe {
8355             let next_ptr = next as *mut T as *mut BaseOutStructure;
8356             let last_next = ptr_chain_iter(next).last().unwrap();
8357             (*last_next).p_next = self.inner.p_next as _;
8358             self.inner.p_next = next_ptr as _;
8359         }
8360         self
8361     }
8362     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8363     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8364     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> EventCreateInfo8365     pub fn build(self) -> EventCreateInfo {
8366         self.inner
8367     }
8368 }
8369 #[repr(C)]
8370 #[derive(Copy, Clone, Debug)]
8371 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateInfo.html>"]
8372 pub struct FenceCreateInfo {
8373     pub s_type: StructureType,
8374     pub p_next: *const c_void,
8375     pub flags: FenceCreateFlags,
8376 }
8377 impl ::std::default::Default for FenceCreateInfo {
default() -> FenceCreateInfo8378     fn default() -> FenceCreateInfo {
8379         FenceCreateInfo {
8380             s_type: StructureType::FENCE_CREATE_INFO,
8381             p_next: ::std::ptr::null(),
8382             flags: FenceCreateFlags::default(),
8383         }
8384     }
8385 }
8386 impl FenceCreateInfo {
builder<'a>() -> FenceCreateInfoBuilder<'a>8387     pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> {
8388         FenceCreateInfoBuilder {
8389             inner: FenceCreateInfo::default(),
8390             marker: ::std::marker::PhantomData,
8391         }
8392     }
8393 }
8394 #[repr(transparent)]
8395 pub struct FenceCreateInfoBuilder<'a> {
8396     inner: FenceCreateInfo,
8397     marker: ::std::marker::PhantomData<&'a ()>,
8398 }
8399 pub unsafe trait ExtendsFenceCreateInfo {}
8400 impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> {
8401     type Target = FenceCreateInfo;
deref(&self) -> &Self::Target8402     fn deref(&self) -> &Self::Target {
8403         &self.inner
8404     }
8405 }
8406 impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8407     fn deref_mut(&mut self) -> &mut Self::Target {
8408         &mut self.inner
8409     }
8410 }
8411 impl<'a> FenceCreateInfoBuilder<'a> {
flags(mut self, flags: FenceCreateFlags) -> FenceCreateInfoBuilder<'a>8412     pub fn flags(mut self, flags: FenceCreateFlags) -> FenceCreateInfoBuilder<'a> {
8413         self.inner.flags = flags;
8414         self
8415     }
8416     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
8417     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
8418     #[doc = r" valid extension structs can be pushed into the chain."]
8419     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
8420     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFenceCreateInfo>( mut self, next: &'a mut T, ) -> FenceCreateInfoBuilder<'a>8421     pub fn push_next<T: ExtendsFenceCreateInfo>(
8422         mut self,
8423         next: &'a mut T,
8424     ) -> FenceCreateInfoBuilder<'a> {
8425         unsafe {
8426             let next_ptr = next as *mut T as *mut BaseOutStructure;
8427             let last_next = ptr_chain_iter(next).last().unwrap();
8428             (*last_next).p_next = self.inner.p_next as _;
8429             self.inner.p_next = next_ptr as _;
8430         }
8431         self
8432     }
8433     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8434     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8435     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FenceCreateInfo8436     pub fn build(self) -> FenceCreateInfo {
8437         self.inner
8438     }
8439 }
8440 #[repr(C)]
8441 #[derive(Copy, Clone, Default, Debug)]
8442 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html>"]
8443 pub struct PhysicalDeviceFeatures {
8444     pub robust_buffer_access: Bool32,
8445     pub full_draw_index_uint32: Bool32,
8446     pub image_cube_array: Bool32,
8447     pub independent_blend: Bool32,
8448     pub geometry_shader: Bool32,
8449     pub tessellation_shader: Bool32,
8450     pub sample_rate_shading: Bool32,
8451     pub dual_src_blend: Bool32,
8452     pub logic_op: Bool32,
8453     pub multi_draw_indirect: Bool32,
8454     pub draw_indirect_first_instance: Bool32,
8455     pub depth_clamp: Bool32,
8456     pub depth_bias_clamp: Bool32,
8457     pub fill_mode_non_solid: Bool32,
8458     pub depth_bounds: Bool32,
8459     pub wide_lines: Bool32,
8460     pub large_points: Bool32,
8461     pub alpha_to_one: Bool32,
8462     pub multi_viewport: Bool32,
8463     pub sampler_anisotropy: Bool32,
8464     pub texture_compression_etc2: Bool32,
8465     pub texture_compression_astc_ldr: Bool32,
8466     pub texture_compression_bc: Bool32,
8467     pub occlusion_query_precise: Bool32,
8468     pub pipeline_statistics_query: Bool32,
8469     pub vertex_pipeline_stores_and_atomics: Bool32,
8470     pub fragment_stores_and_atomics: Bool32,
8471     pub shader_tessellation_and_geometry_point_size: Bool32,
8472     pub shader_image_gather_extended: Bool32,
8473     pub shader_storage_image_extended_formats: Bool32,
8474     pub shader_storage_image_multisample: Bool32,
8475     pub shader_storage_image_read_without_format: Bool32,
8476     pub shader_storage_image_write_without_format: Bool32,
8477     pub shader_uniform_buffer_array_dynamic_indexing: Bool32,
8478     pub shader_sampled_image_array_dynamic_indexing: Bool32,
8479     pub shader_storage_buffer_array_dynamic_indexing: Bool32,
8480     pub shader_storage_image_array_dynamic_indexing: Bool32,
8481     pub shader_clip_distance: Bool32,
8482     pub shader_cull_distance: Bool32,
8483     pub shader_float64: Bool32,
8484     pub shader_int64: Bool32,
8485     pub shader_int16: Bool32,
8486     pub shader_resource_residency: Bool32,
8487     pub shader_resource_min_lod: Bool32,
8488     pub sparse_binding: Bool32,
8489     pub sparse_residency_buffer: Bool32,
8490     pub sparse_residency_image2_d: Bool32,
8491     pub sparse_residency_image3_d: Bool32,
8492     pub sparse_residency2_samples: Bool32,
8493     pub sparse_residency4_samples: Bool32,
8494     pub sparse_residency8_samples: Bool32,
8495     pub sparse_residency16_samples: Bool32,
8496     pub sparse_residency_aliased: Bool32,
8497     pub variable_multisample_rate: Bool32,
8498     pub inherited_queries: Bool32,
8499 }
8500 impl PhysicalDeviceFeatures {
builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a>8501     pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> {
8502         PhysicalDeviceFeaturesBuilder {
8503             inner: PhysicalDeviceFeatures::default(),
8504             marker: ::std::marker::PhantomData,
8505         }
8506     }
8507 }
8508 #[repr(transparent)]
8509 pub struct PhysicalDeviceFeaturesBuilder<'a> {
8510     inner: PhysicalDeviceFeatures,
8511     marker: ::std::marker::PhantomData<&'a ()>,
8512 }
8513 impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> {
8514     type Target = PhysicalDeviceFeatures;
deref(&self) -> &Self::Target8515     fn deref(&self) -> &Self::Target {
8516         &self.inner
8517     }
8518 }
8519 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8520     fn deref_mut(&mut self) -> &mut Self::Target {
8521         &mut self.inner
8522     }
8523 }
8524 impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
robust_buffer_access( mut self, robust_buffer_access: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8525     pub fn robust_buffer_access(
8526         mut self,
8527         robust_buffer_access: bool,
8528     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8529         self.inner.robust_buffer_access = robust_buffer_access.into();
8530         self
8531     }
full_draw_index_uint32( mut self, full_draw_index_uint32: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8532     pub fn full_draw_index_uint32(
8533         mut self,
8534         full_draw_index_uint32: bool,
8535     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8536         self.inner.full_draw_index_uint32 = full_draw_index_uint32.into();
8537         self
8538     }
image_cube_array(mut self, image_cube_array: bool) -> PhysicalDeviceFeaturesBuilder<'a>8539     pub fn image_cube_array(mut self, image_cube_array: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8540         self.inner.image_cube_array = image_cube_array.into();
8541         self
8542     }
independent_blend( mut self, independent_blend: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8543     pub fn independent_blend(
8544         mut self,
8545         independent_blend: bool,
8546     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8547         self.inner.independent_blend = independent_blend.into();
8548         self
8549     }
geometry_shader(mut self, geometry_shader: bool) -> PhysicalDeviceFeaturesBuilder<'a>8550     pub fn geometry_shader(mut self, geometry_shader: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8551         self.inner.geometry_shader = geometry_shader.into();
8552         self
8553     }
tessellation_shader( mut self, tessellation_shader: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8554     pub fn tessellation_shader(
8555         mut self,
8556         tessellation_shader: bool,
8557     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8558         self.inner.tessellation_shader = tessellation_shader.into();
8559         self
8560     }
sample_rate_shading( mut self, sample_rate_shading: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8561     pub fn sample_rate_shading(
8562         mut self,
8563         sample_rate_shading: bool,
8564     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8565         self.inner.sample_rate_shading = sample_rate_shading.into();
8566         self
8567     }
dual_src_blend(mut self, dual_src_blend: bool) -> PhysicalDeviceFeaturesBuilder<'a>8568     pub fn dual_src_blend(mut self, dual_src_blend: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8569         self.inner.dual_src_blend = dual_src_blend.into();
8570         self
8571     }
logic_op(mut self, logic_op: bool) -> PhysicalDeviceFeaturesBuilder<'a>8572     pub fn logic_op(mut self, logic_op: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8573         self.inner.logic_op = logic_op.into();
8574         self
8575     }
multi_draw_indirect( mut self, multi_draw_indirect: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8576     pub fn multi_draw_indirect(
8577         mut self,
8578         multi_draw_indirect: bool,
8579     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8580         self.inner.multi_draw_indirect = multi_draw_indirect.into();
8581         self
8582     }
draw_indirect_first_instance( mut self, draw_indirect_first_instance: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8583     pub fn draw_indirect_first_instance(
8584         mut self,
8585         draw_indirect_first_instance: bool,
8586     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8587         self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into();
8588         self
8589     }
depth_clamp(mut self, depth_clamp: bool) -> PhysicalDeviceFeaturesBuilder<'a>8590     pub fn depth_clamp(mut self, depth_clamp: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8591         self.inner.depth_clamp = depth_clamp.into();
8592         self
8593     }
depth_bias_clamp(mut self, depth_bias_clamp: bool) -> PhysicalDeviceFeaturesBuilder<'a>8594     pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8595         self.inner.depth_bias_clamp = depth_bias_clamp.into();
8596         self
8597     }
fill_mode_non_solid( mut self, fill_mode_non_solid: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8598     pub fn fill_mode_non_solid(
8599         mut self,
8600         fill_mode_non_solid: bool,
8601     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8602         self.inner.fill_mode_non_solid = fill_mode_non_solid.into();
8603         self
8604     }
depth_bounds(mut self, depth_bounds: bool) -> PhysicalDeviceFeaturesBuilder<'a>8605     pub fn depth_bounds(mut self, depth_bounds: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8606         self.inner.depth_bounds = depth_bounds.into();
8607         self
8608     }
wide_lines(mut self, wide_lines: bool) -> PhysicalDeviceFeaturesBuilder<'a>8609     pub fn wide_lines(mut self, wide_lines: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8610         self.inner.wide_lines = wide_lines.into();
8611         self
8612     }
large_points(mut self, large_points: bool) -> PhysicalDeviceFeaturesBuilder<'a>8613     pub fn large_points(mut self, large_points: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8614         self.inner.large_points = large_points.into();
8615         self
8616     }
alpha_to_one(mut self, alpha_to_one: bool) -> PhysicalDeviceFeaturesBuilder<'a>8617     pub fn alpha_to_one(mut self, alpha_to_one: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8618         self.inner.alpha_to_one = alpha_to_one.into();
8619         self
8620     }
multi_viewport(mut self, multi_viewport: bool) -> PhysicalDeviceFeaturesBuilder<'a>8621     pub fn multi_viewport(mut self, multi_viewport: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8622         self.inner.multi_viewport = multi_viewport.into();
8623         self
8624     }
sampler_anisotropy( mut self, sampler_anisotropy: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8625     pub fn sampler_anisotropy(
8626         mut self,
8627         sampler_anisotropy: bool,
8628     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8629         self.inner.sampler_anisotropy = sampler_anisotropy.into();
8630         self
8631     }
texture_compression_etc2( mut self, texture_compression_etc2: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8632     pub fn texture_compression_etc2(
8633         mut self,
8634         texture_compression_etc2: bool,
8635     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8636         self.inner.texture_compression_etc2 = texture_compression_etc2.into();
8637         self
8638     }
texture_compression_astc_ldr( mut self, texture_compression_astc_ldr: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8639     pub fn texture_compression_astc_ldr(
8640         mut self,
8641         texture_compression_astc_ldr: bool,
8642     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8643         self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into();
8644         self
8645     }
texture_compression_bc( mut self, texture_compression_bc: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8646     pub fn texture_compression_bc(
8647         mut self,
8648         texture_compression_bc: bool,
8649     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8650         self.inner.texture_compression_bc = texture_compression_bc.into();
8651         self
8652     }
occlusion_query_precise( mut self, occlusion_query_precise: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8653     pub fn occlusion_query_precise(
8654         mut self,
8655         occlusion_query_precise: bool,
8656     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8657         self.inner.occlusion_query_precise = occlusion_query_precise.into();
8658         self
8659     }
pipeline_statistics_query( mut self, pipeline_statistics_query: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8660     pub fn pipeline_statistics_query(
8661         mut self,
8662         pipeline_statistics_query: bool,
8663     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8664         self.inner.pipeline_statistics_query = pipeline_statistics_query.into();
8665         self
8666     }
vertex_pipeline_stores_and_atomics( mut self, vertex_pipeline_stores_and_atomics: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8667     pub fn vertex_pipeline_stores_and_atomics(
8668         mut self,
8669         vertex_pipeline_stores_and_atomics: bool,
8670     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8671         self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into();
8672         self
8673     }
fragment_stores_and_atomics( mut self, fragment_stores_and_atomics: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8674     pub fn fragment_stores_and_atomics(
8675         mut self,
8676         fragment_stores_and_atomics: bool,
8677     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8678         self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into();
8679         self
8680     }
shader_tessellation_and_geometry_point_size( mut self, shader_tessellation_and_geometry_point_size: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8681     pub fn shader_tessellation_and_geometry_point_size(
8682         mut self,
8683         shader_tessellation_and_geometry_point_size: bool,
8684     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8685         self.inner.shader_tessellation_and_geometry_point_size =
8686             shader_tessellation_and_geometry_point_size.into();
8687         self
8688     }
shader_image_gather_extended( mut self, shader_image_gather_extended: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8689     pub fn shader_image_gather_extended(
8690         mut self,
8691         shader_image_gather_extended: bool,
8692     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8693         self.inner.shader_image_gather_extended = shader_image_gather_extended.into();
8694         self
8695     }
shader_storage_image_extended_formats( mut self, shader_storage_image_extended_formats: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8696     pub fn shader_storage_image_extended_formats(
8697         mut self,
8698         shader_storage_image_extended_formats: bool,
8699     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8700         self.inner.shader_storage_image_extended_formats =
8701             shader_storage_image_extended_formats.into();
8702         self
8703     }
shader_storage_image_multisample( mut self, shader_storage_image_multisample: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8704     pub fn shader_storage_image_multisample(
8705         mut self,
8706         shader_storage_image_multisample: bool,
8707     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8708         self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into();
8709         self
8710     }
shader_storage_image_read_without_format( mut self, shader_storage_image_read_without_format: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8711     pub fn shader_storage_image_read_without_format(
8712         mut self,
8713         shader_storage_image_read_without_format: bool,
8714     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8715         self.inner.shader_storage_image_read_without_format =
8716             shader_storage_image_read_without_format.into();
8717         self
8718     }
shader_storage_image_write_without_format( mut self, shader_storage_image_write_without_format: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8719     pub fn shader_storage_image_write_without_format(
8720         mut self,
8721         shader_storage_image_write_without_format: bool,
8722     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8723         self.inner.shader_storage_image_write_without_format =
8724             shader_storage_image_write_without_format.into();
8725         self
8726     }
shader_uniform_buffer_array_dynamic_indexing( mut self, shader_uniform_buffer_array_dynamic_indexing: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8727     pub fn shader_uniform_buffer_array_dynamic_indexing(
8728         mut self,
8729         shader_uniform_buffer_array_dynamic_indexing: bool,
8730     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8731         self.inner.shader_uniform_buffer_array_dynamic_indexing =
8732             shader_uniform_buffer_array_dynamic_indexing.into();
8733         self
8734     }
shader_sampled_image_array_dynamic_indexing( mut self, shader_sampled_image_array_dynamic_indexing: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8735     pub fn shader_sampled_image_array_dynamic_indexing(
8736         mut self,
8737         shader_sampled_image_array_dynamic_indexing: bool,
8738     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8739         self.inner.shader_sampled_image_array_dynamic_indexing =
8740             shader_sampled_image_array_dynamic_indexing.into();
8741         self
8742     }
shader_storage_buffer_array_dynamic_indexing( mut self, shader_storage_buffer_array_dynamic_indexing: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8743     pub fn shader_storage_buffer_array_dynamic_indexing(
8744         mut self,
8745         shader_storage_buffer_array_dynamic_indexing: bool,
8746     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8747         self.inner.shader_storage_buffer_array_dynamic_indexing =
8748             shader_storage_buffer_array_dynamic_indexing.into();
8749         self
8750     }
shader_storage_image_array_dynamic_indexing( mut self, shader_storage_image_array_dynamic_indexing: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8751     pub fn shader_storage_image_array_dynamic_indexing(
8752         mut self,
8753         shader_storage_image_array_dynamic_indexing: bool,
8754     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8755         self.inner.shader_storage_image_array_dynamic_indexing =
8756             shader_storage_image_array_dynamic_indexing.into();
8757         self
8758     }
shader_clip_distance( mut self, shader_clip_distance: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8759     pub fn shader_clip_distance(
8760         mut self,
8761         shader_clip_distance: bool,
8762     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8763         self.inner.shader_clip_distance = shader_clip_distance.into();
8764         self
8765     }
shader_cull_distance( mut self, shader_cull_distance: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8766     pub fn shader_cull_distance(
8767         mut self,
8768         shader_cull_distance: bool,
8769     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8770         self.inner.shader_cull_distance = shader_cull_distance.into();
8771         self
8772     }
shader_float64(mut self, shader_float64: bool) -> PhysicalDeviceFeaturesBuilder<'a>8773     pub fn shader_float64(mut self, shader_float64: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8774         self.inner.shader_float64 = shader_float64.into();
8775         self
8776     }
shader_int64(mut self, shader_int64: bool) -> PhysicalDeviceFeaturesBuilder<'a>8777     pub fn shader_int64(mut self, shader_int64: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8778         self.inner.shader_int64 = shader_int64.into();
8779         self
8780     }
shader_int16(mut self, shader_int16: bool) -> PhysicalDeviceFeaturesBuilder<'a>8781     pub fn shader_int16(mut self, shader_int16: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8782         self.inner.shader_int16 = shader_int16.into();
8783         self
8784     }
shader_resource_residency( mut self, shader_resource_residency: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8785     pub fn shader_resource_residency(
8786         mut self,
8787         shader_resource_residency: bool,
8788     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8789         self.inner.shader_resource_residency = shader_resource_residency.into();
8790         self
8791     }
shader_resource_min_lod( mut self, shader_resource_min_lod: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8792     pub fn shader_resource_min_lod(
8793         mut self,
8794         shader_resource_min_lod: bool,
8795     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8796         self.inner.shader_resource_min_lod = shader_resource_min_lod.into();
8797         self
8798     }
sparse_binding(mut self, sparse_binding: bool) -> PhysicalDeviceFeaturesBuilder<'a>8799     pub fn sparse_binding(mut self, sparse_binding: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
8800         self.inner.sparse_binding = sparse_binding.into();
8801         self
8802     }
sparse_residency_buffer( mut self, sparse_residency_buffer: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8803     pub fn sparse_residency_buffer(
8804         mut self,
8805         sparse_residency_buffer: bool,
8806     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8807         self.inner.sparse_residency_buffer = sparse_residency_buffer.into();
8808         self
8809     }
sparse_residency_image2_d( mut self, sparse_residency_image2_d: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8810     pub fn sparse_residency_image2_d(
8811         mut self,
8812         sparse_residency_image2_d: bool,
8813     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8814         self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into();
8815         self
8816     }
sparse_residency_image3_d( mut self, sparse_residency_image3_d: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8817     pub fn sparse_residency_image3_d(
8818         mut self,
8819         sparse_residency_image3_d: bool,
8820     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8821         self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into();
8822         self
8823     }
sparse_residency2_samples( mut self, sparse_residency2_samples: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8824     pub fn sparse_residency2_samples(
8825         mut self,
8826         sparse_residency2_samples: bool,
8827     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8828         self.inner.sparse_residency2_samples = sparse_residency2_samples.into();
8829         self
8830     }
sparse_residency4_samples( mut self, sparse_residency4_samples: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8831     pub fn sparse_residency4_samples(
8832         mut self,
8833         sparse_residency4_samples: bool,
8834     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8835         self.inner.sparse_residency4_samples = sparse_residency4_samples.into();
8836         self
8837     }
sparse_residency8_samples( mut self, sparse_residency8_samples: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8838     pub fn sparse_residency8_samples(
8839         mut self,
8840         sparse_residency8_samples: bool,
8841     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8842         self.inner.sparse_residency8_samples = sparse_residency8_samples.into();
8843         self
8844     }
sparse_residency16_samples( mut self, sparse_residency16_samples: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8845     pub fn sparse_residency16_samples(
8846         mut self,
8847         sparse_residency16_samples: bool,
8848     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8849         self.inner.sparse_residency16_samples = sparse_residency16_samples.into();
8850         self
8851     }
sparse_residency_aliased( mut self, sparse_residency_aliased: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8852     pub fn sparse_residency_aliased(
8853         mut self,
8854         sparse_residency_aliased: bool,
8855     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8856         self.inner.sparse_residency_aliased = sparse_residency_aliased.into();
8857         self
8858     }
variable_multisample_rate( mut self, variable_multisample_rate: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8859     pub fn variable_multisample_rate(
8860         mut self,
8861         variable_multisample_rate: bool,
8862     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8863         self.inner.variable_multisample_rate = variable_multisample_rate.into();
8864         self
8865     }
inherited_queries( mut self, inherited_queries: bool, ) -> PhysicalDeviceFeaturesBuilder<'a>8866     pub fn inherited_queries(
8867         mut self,
8868         inherited_queries: bool,
8869     ) -> PhysicalDeviceFeaturesBuilder<'a> {
8870         self.inner.inherited_queries = inherited_queries.into();
8871         self
8872     }
8873     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8874     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8875     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFeatures8876     pub fn build(self) -> PhysicalDeviceFeatures {
8877         self.inner
8878     }
8879 }
8880 #[repr(C)]
8881 #[derive(Copy, Clone, Default, Debug)]
8882 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html>"]
8883 pub struct PhysicalDeviceSparseProperties {
8884     pub residency_standard2_d_block_shape: Bool32,
8885     pub residency_standard2_d_multisample_block_shape: Bool32,
8886     pub residency_standard3_d_block_shape: Bool32,
8887     pub residency_aligned_mip_size: Bool32,
8888     pub residency_non_resident_strict: Bool32,
8889 }
8890 impl PhysicalDeviceSparseProperties {
builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a>8891     pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8892         PhysicalDeviceSparsePropertiesBuilder {
8893             inner: PhysicalDeviceSparseProperties::default(),
8894             marker: ::std::marker::PhantomData,
8895         }
8896     }
8897 }
8898 #[repr(transparent)]
8899 pub struct PhysicalDeviceSparsePropertiesBuilder<'a> {
8900     inner: PhysicalDeviceSparseProperties,
8901     marker: ::std::marker::PhantomData<&'a ()>,
8902 }
8903 impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> {
8904     type Target = PhysicalDeviceSparseProperties;
deref(&self) -> &Self::Target8905     fn deref(&self) -> &Self::Target {
8906         &self.inner
8907     }
8908 }
8909 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target8910     fn deref_mut(&mut self) -> &mut Self::Target {
8911         &mut self.inner
8912     }
8913 }
8914 impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
residency_standard2_d_block_shape( mut self, residency_standard2_d_block_shape: bool, ) -> PhysicalDeviceSparsePropertiesBuilder<'a>8915     pub fn residency_standard2_d_block_shape(
8916         mut self,
8917         residency_standard2_d_block_shape: bool,
8918     ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8919         self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into();
8920         self
8921     }
residency_standard2_d_multisample_block_shape( mut self, residency_standard2_d_multisample_block_shape: bool, ) -> PhysicalDeviceSparsePropertiesBuilder<'a>8922     pub fn residency_standard2_d_multisample_block_shape(
8923         mut self,
8924         residency_standard2_d_multisample_block_shape: bool,
8925     ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8926         self.inner.residency_standard2_d_multisample_block_shape =
8927             residency_standard2_d_multisample_block_shape.into();
8928         self
8929     }
residency_standard3_d_block_shape( mut self, residency_standard3_d_block_shape: bool, ) -> PhysicalDeviceSparsePropertiesBuilder<'a>8930     pub fn residency_standard3_d_block_shape(
8931         mut self,
8932         residency_standard3_d_block_shape: bool,
8933     ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8934         self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into();
8935         self
8936     }
residency_aligned_mip_size( mut self, residency_aligned_mip_size: bool, ) -> PhysicalDeviceSparsePropertiesBuilder<'a>8937     pub fn residency_aligned_mip_size(
8938         mut self,
8939         residency_aligned_mip_size: bool,
8940     ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8941         self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into();
8942         self
8943     }
residency_non_resident_strict( mut self, residency_non_resident_strict: bool, ) -> PhysicalDeviceSparsePropertiesBuilder<'a>8944     pub fn residency_non_resident_strict(
8945         mut self,
8946         residency_non_resident_strict: bool,
8947     ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
8948         self.inner.residency_non_resident_strict = residency_non_resident_strict.into();
8949         self
8950     }
8951     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
8952     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
8953     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSparseProperties8954     pub fn build(self) -> PhysicalDeviceSparseProperties {
8955         self.inner
8956     }
8957 }
8958 #[repr(C)]
8959 #[derive(Copy, Clone, Debug)]
8960 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html>"]
8961 pub struct PhysicalDeviceLimits {
8962     pub max_image_dimension1_d: u32,
8963     pub max_image_dimension2_d: u32,
8964     pub max_image_dimension3_d: u32,
8965     pub max_image_dimension_cube: u32,
8966     pub max_image_array_layers: u32,
8967     pub max_texel_buffer_elements: u32,
8968     pub max_uniform_buffer_range: u32,
8969     pub max_storage_buffer_range: u32,
8970     pub max_push_constants_size: u32,
8971     pub max_memory_allocation_count: u32,
8972     pub max_sampler_allocation_count: u32,
8973     pub buffer_image_granularity: DeviceSize,
8974     pub sparse_address_space_size: DeviceSize,
8975     pub max_bound_descriptor_sets: u32,
8976     pub max_per_stage_descriptor_samplers: u32,
8977     pub max_per_stage_descriptor_uniform_buffers: u32,
8978     pub max_per_stage_descriptor_storage_buffers: u32,
8979     pub max_per_stage_descriptor_sampled_images: u32,
8980     pub max_per_stage_descriptor_storage_images: u32,
8981     pub max_per_stage_descriptor_input_attachments: u32,
8982     pub max_per_stage_resources: u32,
8983     pub max_descriptor_set_samplers: u32,
8984     pub max_descriptor_set_uniform_buffers: u32,
8985     pub max_descriptor_set_uniform_buffers_dynamic: u32,
8986     pub max_descriptor_set_storage_buffers: u32,
8987     pub max_descriptor_set_storage_buffers_dynamic: u32,
8988     pub max_descriptor_set_sampled_images: u32,
8989     pub max_descriptor_set_storage_images: u32,
8990     pub max_descriptor_set_input_attachments: u32,
8991     pub max_vertex_input_attributes: u32,
8992     pub max_vertex_input_bindings: u32,
8993     pub max_vertex_input_attribute_offset: u32,
8994     pub max_vertex_input_binding_stride: u32,
8995     pub max_vertex_output_components: u32,
8996     pub max_tessellation_generation_level: u32,
8997     pub max_tessellation_patch_size: u32,
8998     pub max_tessellation_control_per_vertex_input_components: u32,
8999     pub max_tessellation_control_per_vertex_output_components: u32,
9000     pub max_tessellation_control_per_patch_output_components: u32,
9001     pub max_tessellation_control_total_output_components: u32,
9002     pub max_tessellation_evaluation_input_components: u32,
9003     pub max_tessellation_evaluation_output_components: u32,
9004     pub max_geometry_shader_invocations: u32,
9005     pub max_geometry_input_components: u32,
9006     pub max_geometry_output_components: u32,
9007     pub max_geometry_output_vertices: u32,
9008     pub max_geometry_total_output_components: u32,
9009     pub max_fragment_input_components: u32,
9010     pub max_fragment_output_attachments: u32,
9011     pub max_fragment_dual_src_attachments: u32,
9012     pub max_fragment_combined_output_resources: u32,
9013     pub max_compute_shared_memory_size: u32,
9014     pub max_compute_work_group_count: [u32; 3],
9015     pub max_compute_work_group_invocations: u32,
9016     pub max_compute_work_group_size: [u32; 3],
9017     pub sub_pixel_precision_bits: u32,
9018     pub sub_texel_precision_bits: u32,
9019     pub mipmap_precision_bits: u32,
9020     pub max_draw_indexed_index_value: u32,
9021     pub max_draw_indirect_count: u32,
9022     pub max_sampler_lod_bias: f32,
9023     pub max_sampler_anisotropy: f32,
9024     pub max_viewports: u32,
9025     pub max_viewport_dimensions: [u32; 2],
9026     pub viewport_bounds_range: [f32; 2],
9027     pub viewport_sub_pixel_bits: u32,
9028     pub min_memory_map_alignment: usize,
9029     pub min_texel_buffer_offset_alignment: DeviceSize,
9030     pub min_uniform_buffer_offset_alignment: DeviceSize,
9031     pub min_storage_buffer_offset_alignment: DeviceSize,
9032     pub min_texel_offset: i32,
9033     pub max_texel_offset: u32,
9034     pub min_texel_gather_offset: i32,
9035     pub max_texel_gather_offset: u32,
9036     pub min_interpolation_offset: f32,
9037     pub max_interpolation_offset: f32,
9038     pub sub_pixel_interpolation_offset_bits: u32,
9039     pub max_framebuffer_width: u32,
9040     pub max_framebuffer_height: u32,
9041     pub max_framebuffer_layers: u32,
9042     pub framebuffer_color_sample_counts: SampleCountFlags,
9043     pub framebuffer_depth_sample_counts: SampleCountFlags,
9044     pub framebuffer_stencil_sample_counts: SampleCountFlags,
9045     pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
9046     pub max_color_attachments: u32,
9047     pub sampled_image_color_sample_counts: SampleCountFlags,
9048     pub sampled_image_integer_sample_counts: SampleCountFlags,
9049     pub sampled_image_depth_sample_counts: SampleCountFlags,
9050     pub sampled_image_stencil_sample_counts: SampleCountFlags,
9051     pub storage_image_sample_counts: SampleCountFlags,
9052     pub max_sample_mask_words: u32,
9053     pub timestamp_compute_and_graphics: Bool32,
9054     pub timestamp_period: f32,
9055     pub max_clip_distances: u32,
9056     pub max_cull_distances: u32,
9057     pub max_combined_clip_and_cull_distances: u32,
9058     pub discrete_queue_priorities: u32,
9059     pub point_size_range: [f32; 2],
9060     pub line_width_range: [f32; 2],
9061     pub point_size_granularity: f32,
9062     pub line_width_granularity: f32,
9063     pub strict_lines: Bool32,
9064     pub standard_sample_locations: Bool32,
9065     pub optimal_buffer_copy_offset_alignment: DeviceSize,
9066     pub optimal_buffer_copy_row_pitch_alignment: DeviceSize,
9067     pub non_coherent_atom_size: DeviceSize,
9068 }
9069 impl ::std::default::Default for PhysicalDeviceLimits {
default() -> PhysicalDeviceLimits9070     fn default() -> PhysicalDeviceLimits {
9071         PhysicalDeviceLimits {
9072             max_image_dimension1_d: u32::default(),
9073             max_image_dimension2_d: u32::default(),
9074             max_image_dimension3_d: u32::default(),
9075             max_image_dimension_cube: u32::default(),
9076             max_image_array_layers: u32::default(),
9077             max_texel_buffer_elements: u32::default(),
9078             max_uniform_buffer_range: u32::default(),
9079             max_storage_buffer_range: u32::default(),
9080             max_push_constants_size: u32::default(),
9081             max_memory_allocation_count: u32::default(),
9082             max_sampler_allocation_count: u32::default(),
9083             buffer_image_granularity: DeviceSize::default(),
9084             sparse_address_space_size: DeviceSize::default(),
9085             max_bound_descriptor_sets: u32::default(),
9086             max_per_stage_descriptor_samplers: u32::default(),
9087             max_per_stage_descriptor_uniform_buffers: u32::default(),
9088             max_per_stage_descriptor_storage_buffers: u32::default(),
9089             max_per_stage_descriptor_sampled_images: u32::default(),
9090             max_per_stage_descriptor_storage_images: u32::default(),
9091             max_per_stage_descriptor_input_attachments: u32::default(),
9092             max_per_stage_resources: u32::default(),
9093             max_descriptor_set_samplers: u32::default(),
9094             max_descriptor_set_uniform_buffers: u32::default(),
9095             max_descriptor_set_uniform_buffers_dynamic: u32::default(),
9096             max_descriptor_set_storage_buffers: u32::default(),
9097             max_descriptor_set_storage_buffers_dynamic: u32::default(),
9098             max_descriptor_set_sampled_images: u32::default(),
9099             max_descriptor_set_storage_images: u32::default(),
9100             max_descriptor_set_input_attachments: u32::default(),
9101             max_vertex_input_attributes: u32::default(),
9102             max_vertex_input_bindings: u32::default(),
9103             max_vertex_input_attribute_offset: u32::default(),
9104             max_vertex_input_binding_stride: u32::default(),
9105             max_vertex_output_components: u32::default(),
9106             max_tessellation_generation_level: u32::default(),
9107             max_tessellation_patch_size: u32::default(),
9108             max_tessellation_control_per_vertex_input_components: u32::default(),
9109             max_tessellation_control_per_vertex_output_components: u32::default(),
9110             max_tessellation_control_per_patch_output_components: u32::default(),
9111             max_tessellation_control_total_output_components: u32::default(),
9112             max_tessellation_evaluation_input_components: u32::default(),
9113             max_tessellation_evaluation_output_components: u32::default(),
9114             max_geometry_shader_invocations: u32::default(),
9115             max_geometry_input_components: u32::default(),
9116             max_geometry_output_components: u32::default(),
9117             max_geometry_output_vertices: u32::default(),
9118             max_geometry_total_output_components: u32::default(),
9119             max_fragment_input_components: u32::default(),
9120             max_fragment_output_attachments: u32::default(),
9121             max_fragment_dual_src_attachments: u32::default(),
9122             max_fragment_combined_output_resources: u32::default(),
9123             max_compute_shared_memory_size: u32::default(),
9124             max_compute_work_group_count: unsafe { ::std::mem::zeroed() },
9125             max_compute_work_group_invocations: u32::default(),
9126             max_compute_work_group_size: unsafe { ::std::mem::zeroed() },
9127             sub_pixel_precision_bits: u32::default(),
9128             sub_texel_precision_bits: u32::default(),
9129             mipmap_precision_bits: u32::default(),
9130             max_draw_indexed_index_value: u32::default(),
9131             max_draw_indirect_count: u32::default(),
9132             max_sampler_lod_bias: f32::default(),
9133             max_sampler_anisotropy: f32::default(),
9134             max_viewports: u32::default(),
9135             max_viewport_dimensions: unsafe { ::std::mem::zeroed() },
9136             viewport_bounds_range: unsafe { ::std::mem::zeroed() },
9137             viewport_sub_pixel_bits: u32::default(),
9138             min_memory_map_alignment: usize::default(),
9139             min_texel_buffer_offset_alignment: DeviceSize::default(),
9140             min_uniform_buffer_offset_alignment: DeviceSize::default(),
9141             min_storage_buffer_offset_alignment: DeviceSize::default(),
9142             min_texel_offset: i32::default(),
9143             max_texel_offset: u32::default(),
9144             min_texel_gather_offset: i32::default(),
9145             max_texel_gather_offset: u32::default(),
9146             min_interpolation_offset: f32::default(),
9147             max_interpolation_offset: f32::default(),
9148             sub_pixel_interpolation_offset_bits: u32::default(),
9149             max_framebuffer_width: u32::default(),
9150             max_framebuffer_height: u32::default(),
9151             max_framebuffer_layers: u32::default(),
9152             framebuffer_color_sample_counts: SampleCountFlags::default(),
9153             framebuffer_depth_sample_counts: SampleCountFlags::default(),
9154             framebuffer_stencil_sample_counts: SampleCountFlags::default(),
9155             framebuffer_no_attachments_sample_counts: SampleCountFlags::default(),
9156             max_color_attachments: u32::default(),
9157             sampled_image_color_sample_counts: SampleCountFlags::default(),
9158             sampled_image_integer_sample_counts: SampleCountFlags::default(),
9159             sampled_image_depth_sample_counts: SampleCountFlags::default(),
9160             sampled_image_stencil_sample_counts: SampleCountFlags::default(),
9161             storage_image_sample_counts: SampleCountFlags::default(),
9162             max_sample_mask_words: u32::default(),
9163             timestamp_compute_and_graphics: Bool32::default(),
9164             timestamp_period: f32::default(),
9165             max_clip_distances: u32::default(),
9166             max_cull_distances: u32::default(),
9167             max_combined_clip_and_cull_distances: u32::default(),
9168             discrete_queue_priorities: u32::default(),
9169             point_size_range: unsafe { ::std::mem::zeroed() },
9170             line_width_range: unsafe { ::std::mem::zeroed() },
9171             point_size_granularity: f32::default(),
9172             line_width_granularity: f32::default(),
9173             strict_lines: Bool32::default(),
9174             standard_sample_locations: Bool32::default(),
9175             optimal_buffer_copy_offset_alignment: DeviceSize::default(),
9176             optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(),
9177             non_coherent_atom_size: DeviceSize::default(),
9178         }
9179     }
9180 }
9181 impl PhysicalDeviceLimits {
builder<'a>() -> PhysicalDeviceLimitsBuilder<'a>9182     pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> {
9183         PhysicalDeviceLimitsBuilder {
9184             inner: PhysicalDeviceLimits::default(),
9185             marker: ::std::marker::PhantomData,
9186         }
9187     }
9188 }
9189 #[repr(transparent)]
9190 pub struct PhysicalDeviceLimitsBuilder<'a> {
9191     inner: PhysicalDeviceLimits,
9192     marker: ::std::marker::PhantomData<&'a ()>,
9193 }
9194 impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> {
9195     type Target = PhysicalDeviceLimits;
deref(&self) -> &Self::Target9196     fn deref(&self) -> &Self::Target {
9197         &self.inner
9198     }
9199 }
9200 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target9201     fn deref_mut(&mut self) -> &mut Self::Target {
9202         &mut self.inner
9203     }
9204 }
9205 impl<'a> PhysicalDeviceLimitsBuilder<'a> {
max_image_dimension1_d( mut self, max_image_dimension1_d: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9206     pub fn max_image_dimension1_d(
9207         mut self,
9208         max_image_dimension1_d: u32,
9209     ) -> PhysicalDeviceLimitsBuilder<'a> {
9210         self.inner.max_image_dimension1_d = max_image_dimension1_d;
9211         self
9212     }
max_image_dimension2_d( mut self, max_image_dimension2_d: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9213     pub fn max_image_dimension2_d(
9214         mut self,
9215         max_image_dimension2_d: u32,
9216     ) -> PhysicalDeviceLimitsBuilder<'a> {
9217         self.inner.max_image_dimension2_d = max_image_dimension2_d;
9218         self
9219     }
max_image_dimension3_d( mut self, max_image_dimension3_d: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9220     pub fn max_image_dimension3_d(
9221         mut self,
9222         max_image_dimension3_d: u32,
9223     ) -> PhysicalDeviceLimitsBuilder<'a> {
9224         self.inner.max_image_dimension3_d = max_image_dimension3_d;
9225         self
9226     }
max_image_dimension_cube( mut self, max_image_dimension_cube: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9227     pub fn max_image_dimension_cube(
9228         mut self,
9229         max_image_dimension_cube: u32,
9230     ) -> PhysicalDeviceLimitsBuilder<'a> {
9231         self.inner.max_image_dimension_cube = max_image_dimension_cube;
9232         self
9233     }
max_image_array_layers( mut self, max_image_array_layers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9234     pub fn max_image_array_layers(
9235         mut self,
9236         max_image_array_layers: u32,
9237     ) -> PhysicalDeviceLimitsBuilder<'a> {
9238         self.inner.max_image_array_layers = max_image_array_layers;
9239         self
9240     }
max_texel_buffer_elements( mut self, max_texel_buffer_elements: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9241     pub fn max_texel_buffer_elements(
9242         mut self,
9243         max_texel_buffer_elements: u32,
9244     ) -> PhysicalDeviceLimitsBuilder<'a> {
9245         self.inner.max_texel_buffer_elements = max_texel_buffer_elements;
9246         self
9247     }
max_uniform_buffer_range( mut self, max_uniform_buffer_range: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9248     pub fn max_uniform_buffer_range(
9249         mut self,
9250         max_uniform_buffer_range: u32,
9251     ) -> PhysicalDeviceLimitsBuilder<'a> {
9252         self.inner.max_uniform_buffer_range = max_uniform_buffer_range;
9253         self
9254     }
max_storage_buffer_range( mut self, max_storage_buffer_range: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9255     pub fn max_storage_buffer_range(
9256         mut self,
9257         max_storage_buffer_range: u32,
9258     ) -> PhysicalDeviceLimitsBuilder<'a> {
9259         self.inner.max_storage_buffer_range = max_storage_buffer_range;
9260         self
9261     }
max_push_constants_size( mut self, max_push_constants_size: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9262     pub fn max_push_constants_size(
9263         mut self,
9264         max_push_constants_size: u32,
9265     ) -> PhysicalDeviceLimitsBuilder<'a> {
9266         self.inner.max_push_constants_size = max_push_constants_size;
9267         self
9268     }
max_memory_allocation_count( mut self, max_memory_allocation_count: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9269     pub fn max_memory_allocation_count(
9270         mut self,
9271         max_memory_allocation_count: u32,
9272     ) -> PhysicalDeviceLimitsBuilder<'a> {
9273         self.inner.max_memory_allocation_count = max_memory_allocation_count;
9274         self
9275     }
max_sampler_allocation_count( mut self, max_sampler_allocation_count: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9276     pub fn max_sampler_allocation_count(
9277         mut self,
9278         max_sampler_allocation_count: u32,
9279     ) -> PhysicalDeviceLimitsBuilder<'a> {
9280         self.inner.max_sampler_allocation_count = max_sampler_allocation_count;
9281         self
9282     }
buffer_image_granularity( mut self, buffer_image_granularity: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9283     pub fn buffer_image_granularity(
9284         mut self,
9285         buffer_image_granularity: DeviceSize,
9286     ) -> PhysicalDeviceLimitsBuilder<'a> {
9287         self.inner.buffer_image_granularity = buffer_image_granularity;
9288         self
9289     }
sparse_address_space_size( mut self, sparse_address_space_size: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9290     pub fn sparse_address_space_size(
9291         mut self,
9292         sparse_address_space_size: DeviceSize,
9293     ) -> PhysicalDeviceLimitsBuilder<'a> {
9294         self.inner.sparse_address_space_size = sparse_address_space_size;
9295         self
9296     }
max_bound_descriptor_sets( mut self, max_bound_descriptor_sets: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9297     pub fn max_bound_descriptor_sets(
9298         mut self,
9299         max_bound_descriptor_sets: u32,
9300     ) -> PhysicalDeviceLimitsBuilder<'a> {
9301         self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets;
9302         self
9303     }
max_per_stage_descriptor_samplers( mut self, max_per_stage_descriptor_samplers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9304     pub fn max_per_stage_descriptor_samplers(
9305         mut self,
9306         max_per_stage_descriptor_samplers: u32,
9307     ) -> PhysicalDeviceLimitsBuilder<'a> {
9308         self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers;
9309         self
9310     }
max_per_stage_descriptor_uniform_buffers( mut self, max_per_stage_descriptor_uniform_buffers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9311     pub fn max_per_stage_descriptor_uniform_buffers(
9312         mut self,
9313         max_per_stage_descriptor_uniform_buffers: u32,
9314     ) -> PhysicalDeviceLimitsBuilder<'a> {
9315         self.inner.max_per_stage_descriptor_uniform_buffers =
9316             max_per_stage_descriptor_uniform_buffers;
9317         self
9318     }
max_per_stage_descriptor_storage_buffers( mut self, max_per_stage_descriptor_storage_buffers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9319     pub fn max_per_stage_descriptor_storage_buffers(
9320         mut self,
9321         max_per_stage_descriptor_storage_buffers: u32,
9322     ) -> PhysicalDeviceLimitsBuilder<'a> {
9323         self.inner.max_per_stage_descriptor_storage_buffers =
9324             max_per_stage_descriptor_storage_buffers;
9325         self
9326     }
max_per_stage_descriptor_sampled_images( mut self, max_per_stage_descriptor_sampled_images: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9327     pub fn max_per_stage_descriptor_sampled_images(
9328         mut self,
9329         max_per_stage_descriptor_sampled_images: u32,
9330     ) -> PhysicalDeviceLimitsBuilder<'a> {
9331         self.inner.max_per_stage_descriptor_sampled_images =
9332             max_per_stage_descriptor_sampled_images;
9333         self
9334     }
max_per_stage_descriptor_storage_images( mut self, max_per_stage_descriptor_storage_images: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9335     pub fn max_per_stage_descriptor_storage_images(
9336         mut self,
9337         max_per_stage_descriptor_storage_images: u32,
9338     ) -> PhysicalDeviceLimitsBuilder<'a> {
9339         self.inner.max_per_stage_descriptor_storage_images =
9340             max_per_stage_descriptor_storage_images;
9341         self
9342     }
max_per_stage_descriptor_input_attachments( mut self, max_per_stage_descriptor_input_attachments: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9343     pub fn max_per_stage_descriptor_input_attachments(
9344         mut self,
9345         max_per_stage_descriptor_input_attachments: u32,
9346     ) -> PhysicalDeviceLimitsBuilder<'a> {
9347         self.inner.max_per_stage_descriptor_input_attachments =
9348             max_per_stage_descriptor_input_attachments;
9349         self
9350     }
max_per_stage_resources( mut self, max_per_stage_resources: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9351     pub fn max_per_stage_resources(
9352         mut self,
9353         max_per_stage_resources: u32,
9354     ) -> PhysicalDeviceLimitsBuilder<'a> {
9355         self.inner.max_per_stage_resources = max_per_stage_resources;
9356         self
9357     }
max_descriptor_set_samplers( mut self, max_descriptor_set_samplers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9358     pub fn max_descriptor_set_samplers(
9359         mut self,
9360         max_descriptor_set_samplers: u32,
9361     ) -> PhysicalDeviceLimitsBuilder<'a> {
9362         self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers;
9363         self
9364     }
max_descriptor_set_uniform_buffers( mut self, max_descriptor_set_uniform_buffers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9365     pub fn max_descriptor_set_uniform_buffers(
9366         mut self,
9367         max_descriptor_set_uniform_buffers: u32,
9368     ) -> PhysicalDeviceLimitsBuilder<'a> {
9369         self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers;
9370         self
9371     }
max_descriptor_set_uniform_buffers_dynamic( mut self, max_descriptor_set_uniform_buffers_dynamic: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9372     pub fn max_descriptor_set_uniform_buffers_dynamic(
9373         mut self,
9374         max_descriptor_set_uniform_buffers_dynamic: u32,
9375     ) -> PhysicalDeviceLimitsBuilder<'a> {
9376         self.inner.max_descriptor_set_uniform_buffers_dynamic =
9377             max_descriptor_set_uniform_buffers_dynamic;
9378         self
9379     }
max_descriptor_set_storage_buffers( mut self, max_descriptor_set_storage_buffers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9380     pub fn max_descriptor_set_storage_buffers(
9381         mut self,
9382         max_descriptor_set_storage_buffers: u32,
9383     ) -> PhysicalDeviceLimitsBuilder<'a> {
9384         self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers;
9385         self
9386     }
max_descriptor_set_storage_buffers_dynamic( mut self, max_descriptor_set_storage_buffers_dynamic: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9387     pub fn max_descriptor_set_storage_buffers_dynamic(
9388         mut self,
9389         max_descriptor_set_storage_buffers_dynamic: u32,
9390     ) -> PhysicalDeviceLimitsBuilder<'a> {
9391         self.inner.max_descriptor_set_storage_buffers_dynamic =
9392             max_descriptor_set_storage_buffers_dynamic;
9393         self
9394     }
max_descriptor_set_sampled_images( mut self, max_descriptor_set_sampled_images: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9395     pub fn max_descriptor_set_sampled_images(
9396         mut self,
9397         max_descriptor_set_sampled_images: u32,
9398     ) -> PhysicalDeviceLimitsBuilder<'a> {
9399         self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images;
9400         self
9401     }
max_descriptor_set_storage_images( mut self, max_descriptor_set_storage_images: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9402     pub fn max_descriptor_set_storage_images(
9403         mut self,
9404         max_descriptor_set_storage_images: u32,
9405     ) -> PhysicalDeviceLimitsBuilder<'a> {
9406         self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images;
9407         self
9408     }
max_descriptor_set_input_attachments( mut self, max_descriptor_set_input_attachments: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9409     pub fn max_descriptor_set_input_attachments(
9410         mut self,
9411         max_descriptor_set_input_attachments: u32,
9412     ) -> PhysicalDeviceLimitsBuilder<'a> {
9413         self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments;
9414         self
9415     }
max_vertex_input_attributes( mut self, max_vertex_input_attributes: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9416     pub fn max_vertex_input_attributes(
9417         mut self,
9418         max_vertex_input_attributes: u32,
9419     ) -> PhysicalDeviceLimitsBuilder<'a> {
9420         self.inner.max_vertex_input_attributes = max_vertex_input_attributes;
9421         self
9422     }
max_vertex_input_bindings( mut self, max_vertex_input_bindings: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9423     pub fn max_vertex_input_bindings(
9424         mut self,
9425         max_vertex_input_bindings: u32,
9426     ) -> PhysicalDeviceLimitsBuilder<'a> {
9427         self.inner.max_vertex_input_bindings = max_vertex_input_bindings;
9428         self
9429     }
max_vertex_input_attribute_offset( mut self, max_vertex_input_attribute_offset: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9430     pub fn max_vertex_input_attribute_offset(
9431         mut self,
9432         max_vertex_input_attribute_offset: u32,
9433     ) -> PhysicalDeviceLimitsBuilder<'a> {
9434         self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset;
9435         self
9436     }
max_vertex_input_binding_stride( mut self, max_vertex_input_binding_stride: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9437     pub fn max_vertex_input_binding_stride(
9438         mut self,
9439         max_vertex_input_binding_stride: u32,
9440     ) -> PhysicalDeviceLimitsBuilder<'a> {
9441         self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride;
9442         self
9443     }
max_vertex_output_components( mut self, max_vertex_output_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9444     pub fn max_vertex_output_components(
9445         mut self,
9446         max_vertex_output_components: u32,
9447     ) -> PhysicalDeviceLimitsBuilder<'a> {
9448         self.inner.max_vertex_output_components = max_vertex_output_components;
9449         self
9450     }
max_tessellation_generation_level( mut self, max_tessellation_generation_level: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9451     pub fn max_tessellation_generation_level(
9452         mut self,
9453         max_tessellation_generation_level: u32,
9454     ) -> PhysicalDeviceLimitsBuilder<'a> {
9455         self.inner.max_tessellation_generation_level = max_tessellation_generation_level;
9456         self
9457     }
max_tessellation_patch_size( mut self, max_tessellation_patch_size: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9458     pub fn max_tessellation_patch_size(
9459         mut self,
9460         max_tessellation_patch_size: u32,
9461     ) -> PhysicalDeviceLimitsBuilder<'a> {
9462         self.inner.max_tessellation_patch_size = max_tessellation_patch_size;
9463         self
9464     }
max_tessellation_control_per_vertex_input_components( mut self, max_tessellation_control_per_vertex_input_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9465     pub fn max_tessellation_control_per_vertex_input_components(
9466         mut self,
9467         max_tessellation_control_per_vertex_input_components: u32,
9468     ) -> PhysicalDeviceLimitsBuilder<'a> {
9469         self.inner
9470             .max_tessellation_control_per_vertex_input_components =
9471             max_tessellation_control_per_vertex_input_components;
9472         self
9473     }
max_tessellation_control_per_vertex_output_components( mut self, max_tessellation_control_per_vertex_output_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9474     pub fn max_tessellation_control_per_vertex_output_components(
9475         mut self,
9476         max_tessellation_control_per_vertex_output_components: u32,
9477     ) -> PhysicalDeviceLimitsBuilder<'a> {
9478         self.inner
9479             .max_tessellation_control_per_vertex_output_components =
9480             max_tessellation_control_per_vertex_output_components;
9481         self
9482     }
max_tessellation_control_per_patch_output_components( mut self, max_tessellation_control_per_patch_output_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9483     pub fn max_tessellation_control_per_patch_output_components(
9484         mut self,
9485         max_tessellation_control_per_patch_output_components: u32,
9486     ) -> PhysicalDeviceLimitsBuilder<'a> {
9487         self.inner
9488             .max_tessellation_control_per_patch_output_components =
9489             max_tessellation_control_per_patch_output_components;
9490         self
9491     }
max_tessellation_control_total_output_components( mut self, max_tessellation_control_total_output_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9492     pub fn max_tessellation_control_total_output_components(
9493         mut self,
9494         max_tessellation_control_total_output_components: u32,
9495     ) -> PhysicalDeviceLimitsBuilder<'a> {
9496         self.inner.max_tessellation_control_total_output_components =
9497             max_tessellation_control_total_output_components;
9498         self
9499     }
max_tessellation_evaluation_input_components( mut self, max_tessellation_evaluation_input_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9500     pub fn max_tessellation_evaluation_input_components(
9501         mut self,
9502         max_tessellation_evaluation_input_components: u32,
9503     ) -> PhysicalDeviceLimitsBuilder<'a> {
9504         self.inner.max_tessellation_evaluation_input_components =
9505             max_tessellation_evaluation_input_components;
9506         self
9507     }
max_tessellation_evaluation_output_components( mut self, max_tessellation_evaluation_output_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9508     pub fn max_tessellation_evaluation_output_components(
9509         mut self,
9510         max_tessellation_evaluation_output_components: u32,
9511     ) -> PhysicalDeviceLimitsBuilder<'a> {
9512         self.inner.max_tessellation_evaluation_output_components =
9513             max_tessellation_evaluation_output_components;
9514         self
9515     }
max_geometry_shader_invocations( mut self, max_geometry_shader_invocations: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9516     pub fn max_geometry_shader_invocations(
9517         mut self,
9518         max_geometry_shader_invocations: u32,
9519     ) -> PhysicalDeviceLimitsBuilder<'a> {
9520         self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations;
9521         self
9522     }
max_geometry_input_components( mut self, max_geometry_input_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9523     pub fn max_geometry_input_components(
9524         mut self,
9525         max_geometry_input_components: u32,
9526     ) -> PhysicalDeviceLimitsBuilder<'a> {
9527         self.inner.max_geometry_input_components = max_geometry_input_components;
9528         self
9529     }
max_geometry_output_components( mut self, max_geometry_output_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9530     pub fn max_geometry_output_components(
9531         mut self,
9532         max_geometry_output_components: u32,
9533     ) -> PhysicalDeviceLimitsBuilder<'a> {
9534         self.inner.max_geometry_output_components = max_geometry_output_components;
9535         self
9536     }
max_geometry_output_vertices( mut self, max_geometry_output_vertices: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9537     pub fn max_geometry_output_vertices(
9538         mut self,
9539         max_geometry_output_vertices: u32,
9540     ) -> PhysicalDeviceLimitsBuilder<'a> {
9541         self.inner.max_geometry_output_vertices = max_geometry_output_vertices;
9542         self
9543     }
max_geometry_total_output_components( mut self, max_geometry_total_output_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9544     pub fn max_geometry_total_output_components(
9545         mut self,
9546         max_geometry_total_output_components: u32,
9547     ) -> PhysicalDeviceLimitsBuilder<'a> {
9548         self.inner.max_geometry_total_output_components = max_geometry_total_output_components;
9549         self
9550     }
max_fragment_input_components( mut self, max_fragment_input_components: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9551     pub fn max_fragment_input_components(
9552         mut self,
9553         max_fragment_input_components: u32,
9554     ) -> PhysicalDeviceLimitsBuilder<'a> {
9555         self.inner.max_fragment_input_components = max_fragment_input_components;
9556         self
9557     }
max_fragment_output_attachments( mut self, max_fragment_output_attachments: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9558     pub fn max_fragment_output_attachments(
9559         mut self,
9560         max_fragment_output_attachments: u32,
9561     ) -> PhysicalDeviceLimitsBuilder<'a> {
9562         self.inner.max_fragment_output_attachments = max_fragment_output_attachments;
9563         self
9564     }
max_fragment_dual_src_attachments( mut self, max_fragment_dual_src_attachments: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9565     pub fn max_fragment_dual_src_attachments(
9566         mut self,
9567         max_fragment_dual_src_attachments: u32,
9568     ) -> PhysicalDeviceLimitsBuilder<'a> {
9569         self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments;
9570         self
9571     }
max_fragment_combined_output_resources( mut self, max_fragment_combined_output_resources: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9572     pub fn max_fragment_combined_output_resources(
9573         mut self,
9574         max_fragment_combined_output_resources: u32,
9575     ) -> PhysicalDeviceLimitsBuilder<'a> {
9576         self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources;
9577         self
9578     }
max_compute_shared_memory_size( mut self, max_compute_shared_memory_size: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9579     pub fn max_compute_shared_memory_size(
9580         mut self,
9581         max_compute_shared_memory_size: u32,
9582     ) -> PhysicalDeviceLimitsBuilder<'a> {
9583         self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size;
9584         self
9585     }
max_compute_work_group_count( mut self, max_compute_work_group_count: [u32; 3], ) -> PhysicalDeviceLimitsBuilder<'a>9586     pub fn max_compute_work_group_count(
9587         mut self,
9588         max_compute_work_group_count: [u32; 3],
9589     ) -> PhysicalDeviceLimitsBuilder<'a> {
9590         self.inner.max_compute_work_group_count = max_compute_work_group_count;
9591         self
9592     }
max_compute_work_group_invocations( mut self, max_compute_work_group_invocations: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9593     pub fn max_compute_work_group_invocations(
9594         mut self,
9595         max_compute_work_group_invocations: u32,
9596     ) -> PhysicalDeviceLimitsBuilder<'a> {
9597         self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations;
9598         self
9599     }
max_compute_work_group_size( mut self, max_compute_work_group_size: [u32; 3], ) -> PhysicalDeviceLimitsBuilder<'a>9600     pub fn max_compute_work_group_size(
9601         mut self,
9602         max_compute_work_group_size: [u32; 3],
9603     ) -> PhysicalDeviceLimitsBuilder<'a> {
9604         self.inner.max_compute_work_group_size = max_compute_work_group_size;
9605         self
9606     }
sub_pixel_precision_bits( mut self, sub_pixel_precision_bits: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9607     pub fn sub_pixel_precision_bits(
9608         mut self,
9609         sub_pixel_precision_bits: u32,
9610     ) -> PhysicalDeviceLimitsBuilder<'a> {
9611         self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits;
9612         self
9613     }
sub_texel_precision_bits( mut self, sub_texel_precision_bits: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9614     pub fn sub_texel_precision_bits(
9615         mut self,
9616         sub_texel_precision_bits: u32,
9617     ) -> PhysicalDeviceLimitsBuilder<'a> {
9618         self.inner.sub_texel_precision_bits = sub_texel_precision_bits;
9619         self
9620     }
mipmap_precision_bits( mut self, mipmap_precision_bits: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9621     pub fn mipmap_precision_bits(
9622         mut self,
9623         mipmap_precision_bits: u32,
9624     ) -> PhysicalDeviceLimitsBuilder<'a> {
9625         self.inner.mipmap_precision_bits = mipmap_precision_bits;
9626         self
9627     }
max_draw_indexed_index_value( mut self, max_draw_indexed_index_value: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9628     pub fn max_draw_indexed_index_value(
9629         mut self,
9630         max_draw_indexed_index_value: u32,
9631     ) -> PhysicalDeviceLimitsBuilder<'a> {
9632         self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value;
9633         self
9634     }
max_draw_indirect_count( mut self, max_draw_indirect_count: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9635     pub fn max_draw_indirect_count(
9636         mut self,
9637         max_draw_indirect_count: u32,
9638     ) -> PhysicalDeviceLimitsBuilder<'a> {
9639         self.inner.max_draw_indirect_count = max_draw_indirect_count;
9640         self
9641     }
max_sampler_lod_bias( mut self, max_sampler_lod_bias: f32, ) -> PhysicalDeviceLimitsBuilder<'a>9642     pub fn max_sampler_lod_bias(
9643         mut self,
9644         max_sampler_lod_bias: f32,
9645     ) -> PhysicalDeviceLimitsBuilder<'a> {
9646         self.inner.max_sampler_lod_bias = max_sampler_lod_bias;
9647         self
9648     }
max_sampler_anisotropy( mut self, max_sampler_anisotropy: f32, ) -> PhysicalDeviceLimitsBuilder<'a>9649     pub fn max_sampler_anisotropy(
9650         mut self,
9651         max_sampler_anisotropy: f32,
9652     ) -> PhysicalDeviceLimitsBuilder<'a> {
9653         self.inner.max_sampler_anisotropy = max_sampler_anisotropy;
9654         self
9655     }
max_viewports(mut self, max_viewports: u32) -> PhysicalDeviceLimitsBuilder<'a>9656     pub fn max_viewports(mut self, max_viewports: u32) -> PhysicalDeviceLimitsBuilder<'a> {
9657         self.inner.max_viewports = max_viewports;
9658         self
9659     }
max_viewport_dimensions( mut self, max_viewport_dimensions: [u32; 2], ) -> PhysicalDeviceLimitsBuilder<'a>9660     pub fn max_viewport_dimensions(
9661         mut self,
9662         max_viewport_dimensions: [u32; 2],
9663     ) -> PhysicalDeviceLimitsBuilder<'a> {
9664         self.inner.max_viewport_dimensions = max_viewport_dimensions;
9665         self
9666     }
viewport_bounds_range( mut self, viewport_bounds_range: [f32; 2], ) -> PhysicalDeviceLimitsBuilder<'a>9667     pub fn viewport_bounds_range(
9668         mut self,
9669         viewport_bounds_range: [f32; 2],
9670     ) -> PhysicalDeviceLimitsBuilder<'a> {
9671         self.inner.viewport_bounds_range = viewport_bounds_range;
9672         self
9673     }
viewport_sub_pixel_bits( mut self, viewport_sub_pixel_bits: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9674     pub fn viewport_sub_pixel_bits(
9675         mut self,
9676         viewport_sub_pixel_bits: u32,
9677     ) -> PhysicalDeviceLimitsBuilder<'a> {
9678         self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits;
9679         self
9680     }
min_memory_map_alignment( mut self, min_memory_map_alignment: usize, ) -> PhysicalDeviceLimitsBuilder<'a>9681     pub fn min_memory_map_alignment(
9682         mut self,
9683         min_memory_map_alignment: usize,
9684     ) -> PhysicalDeviceLimitsBuilder<'a> {
9685         self.inner.min_memory_map_alignment = min_memory_map_alignment;
9686         self
9687     }
min_texel_buffer_offset_alignment( mut self, min_texel_buffer_offset_alignment: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9688     pub fn min_texel_buffer_offset_alignment(
9689         mut self,
9690         min_texel_buffer_offset_alignment: DeviceSize,
9691     ) -> PhysicalDeviceLimitsBuilder<'a> {
9692         self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment;
9693         self
9694     }
min_uniform_buffer_offset_alignment( mut self, min_uniform_buffer_offset_alignment: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9695     pub fn min_uniform_buffer_offset_alignment(
9696         mut self,
9697         min_uniform_buffer_offset_alignment: DeviceSize,
9698     ) -> PhysicalDeviceLimitsBuilder<'a> {
9699         self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment;
9700         self
9701     }
min_storage_buffer_offset_alignment( mut self, min_storage_buffer_offset_alignment: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9702     pub fn min_storage_buffer_offset_alignment(
9703         mut self,
9704         min_storage_buffer_offset_alignment: DeviceSize,
9705     ) -> PhysicalDeviceLimitsBuilder<'a> {
9706         self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment;
9707         self
9708     }
min_texel_offset(mut self, min_texel_offset: i32) -> PhysicalDeviceLimitsBuilder<'a>9709     pub fn min_texel_offset(mut self, min_texel_offset: i32) -> PhysicalDeviceLimitsBuilder<'a> {
9710         self.inner.min_texel_offset = min_texel_offset;
9711         self
9712     }
max_texel_offset(mut self, max_texel_offset: u32) -> PhysicalDeviceLimitsBuilder<'a>9713     pub fn max_texel_offset(mut self, max_texel_offset: u32) -> PhysicalDeviceLimitsBuilder<'a> {
9714         self.inner.max_texel_offset = max_texel_offset;
9715         self
9716     }
min_texel_gather_offset( mut self, min_texel_gather_offset: i32, ) -> PhysicalDeviceLimitsBuilder<'a>9717     pub fn min_texel_gather_offset(
9718         mut self,
9719         min_texel_gather_offset: i32,
9720     ) -> PhysicalDeviceLimitsBuilder<'a> {
9721         self.inner.min_texel_gather_offset = min_texel_gather_offset;
9722         self
9723     }
max_texel_gather_offset( mut self, max_texel_gather_offset: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9724     pub fn max_texel_gather_offset(
9725         mut self,
9726         max_texel_gather_offset: u32,
9727     ) -> PhysicalDeviceLimitsBuilder<'a> {
9728         self.inner.max_texel_gather_offset = max_texel_gather_offset;
9729         self
9730     }
min_interpolation_offset( mut self, min_interpolation_offset: f32, ) -> PhysicalDeviceLimitsBuilder<'a>9731     pub fn min_interpolation_offset(
9732         mut self,
9733         min_interpolation_offset: f32,
9734     ) -> PhysicalDeviceLimitsBuilder<'a> {
9735         self.inner.min_interpolation_offset = min_interpolation_offset;
9736         self
9737     }
max_interpolation_offset( mut self, max_interpolation_offset: f32, ) -> PhysicalDeviceLimitsBuilder<'a>9738     pub fn max_interpolation_offset(
9739         mut self,
9740         max_interpolation_offset: f32,
9741     ) -> PhysicalDeviceLimitsBuilder<'a> {
9742         self.inner.max_interpolation_offset = max_interpolation_offset;
9743         self
9744     }
sub_pixel_interpolation_offset_bits( mut self, sub_pixel_interpolation_offset_bits: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9745     pub fn sub_pixel_interpolation_offset_bits(
9746         mut self,
9747         sub_pixel_interpolation_offset_bits: u32,
9748     ) -> PhysicalDeviceLimitsBuilder<'a> {
9749         self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits;
9750         self
9751     }
max_framebuffer_width( mut self, max_framebuffer_width: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9752     pub fn max_framebuffer_width(
9753         mut self,
9754         max_framebuffer_width: u32,
9755     ) -> PhysicalDeviceLimitsBuilder<'a> {
9756         self.inner.max_framebuffer_width = max_framebuffer_width;
9757         self
9758     }
max_framebuffer_height( mut self, max_framebuffer_height: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9759     pub fn max_framebuffer_height(
9760         mut self,
9761         max_framebuffer_height: u32,
9762     ) -> PhysicalDeviceLimitsBuilder<'a> {
9763         self.inner.max_framebuffer_height = max_framebuffer_height;
9764         self
9765     }
max_framebuffer_layers( mut self, max_framebuffer_layers: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9766     pub fn max_framebuffer_layers(
9767         mut self,
9768         max_framebuffer_layers: u32,
9769     ) -> PhysicalDeviceLimitsBuilder<'a> {
9770         self.inner.max_framebuffer_layers = max_framebuffer_layers;
9771         self
9772     }
framebuffer_color_sample_counts( mut self, framebuffer_color_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9773     pub fn framebuffer_color_sample_counts(
9774         mut self,
9775         framebuffer_color_sample_counts: SampleCountFlags,
9776     ) -> PhysicalDeviceLimitsBuilder<'a> {
9777         self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts;
9778         self
9779     }
framebuffer_depth_sample_counts( mut self, framebuffer_depth_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9780     pub fn framebuffer_depth_sample_counts(
9781         mut self,
9782         framebuffer_depth_sample_counts: SampleCountFlags,
9783     ) -> PhysicalDeviceLimitsBuilder<'a> {
9784         self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts;
9785         self
9786     }
framebuffer_stencil_sample_counts( mut self, framebuffer_stencil_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9787     pub fn framebuffer_stencil_sample_counts(
9788         mut self,
9789         framebuffer_stencil_sample_counts: SampleCountFlags,
9790     ) -> PhysicalDeviceLimitsBuilder<'a> {
9791         self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts;
9792         self
9793     }
framebuffer_no_attachments_sample_counts( mut self, framebuffer_no_attachments_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9794     pub fn framebuffer_no_attachments_sample_counts(
9795         mut self,
9796         framebuffer_no_attachments_sample_counts: SampleCountFlags,
9797     ) -> PhysicalDeviceLimitsBuilder<'a> {
9798         self.inner.framebuffer_no_attachments_sample_counts =
9799             framebuffer_no_attachments_sample_counts;
9800         self
9801     }
max_color_attachments( mut self, max_color_attachments: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9802     pub fn max_color_attachments(
9803         mut self,
9804         max_color_attachments: u32,
9805     ) -> PhysicalDeviceLimitsBuilder<'a> {
9806         self.inner.max_color_attachments = max_color_attachments;
9807         self
9808     }
sampled_image_color_sample_counts( mut self, sampled_image_color_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9809     pub fn sampled_image_color_sample_counts(
9810         mut self,
9811         sampled_image_color_sample_counts: SampleCountFlags,
9812     ) -> PhysicalDeviceLimitsBuilder<'a> {
9813         self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts;
9814         self
9815     }
sampled_image_integer_sample_counts( mut self, sampled_image_integer_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9816     pub fn sampled_image_integer_sample_counts(
9817         mut self,
9818         sampled_image_integer_sample_counts: SampleCountFlags,
9819     ) -> PhysicalDeviceLimitsBuilder<'a> {
9820         self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts;
9821         self
9822     }
sampled_image_depth_sample_counts( mut self, sampled_image_depth_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9823     pub fn sampled_image_depth_sample_counts(
9824         mut self,
9825         sampled_image_depth_sample_counts: SampleCountFlags,
9826     ) -> PhysicalDeviceLimitsBuilder<'a> {
9827         self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts;
9828         self
9829     }
sampled_image_stencil_sample_counts( mut self, sampled_image_stencil_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9830     pub fn sampled_image_stencil_sample_counts(
9831         mut self,
9832         sampled_image_stencil_sample_counts: SampleCountFlags,
9833     ) -> PhysicalDeviceLimitsBuilder<'a> {
9834         self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts;
9835         self
9836     }
storage_image_sample_counts( mut self, storage_image_sample_counts: SampleCountFlags, ) -> PhysicalDeviceLimitsBuilder<'a>9837     pub fn storage_image_sample_counts(
9838         mut self,
9839         storage_image_sample_counts: SampleCountFlags,
9840     ) -> PhysicalDeviceLimitsBuilder<'a> {
9841         self.inner.storage_image_sample_counts = storage_image_sample_counts;
9842         self
9843     }
max_sample_mask_words( mut self, max_sample_mask_words: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9844     pub fn max_sample_mask_words(
9845         mut self,
9846         max_sample_mask_words: u32,
9847     ) -> PhysicalDeviceLimitsBuilder<'a> {
9848         self.inner.max_sample_mask_words = max_sample_mask_words;
9849         self
9850     }
timestamp_compute_and_graphics( mut self, timestamp_compute_and_graphics: bool, ) -> PhysicalDeviceLimitsBuilder<'a>9851     pub fn timestamp_compute_and_graphics(
9852         mut self,
9853         timestamp_compute_and_graphics: bool,
9854     ) -> PhysicalDeviceLimitsBuilder<'a> {
9855         self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into();
9856         self
9857     }
timestamp_period(mut self, timestamp_period: f32) -> PhysicalDeviceLimitsBuilder<'a>9858     pub fn timestamp_period(mut self, timestamp_period: f32) -> PhysicalDeviceLimitsBuilder<'a> {
9859         self.inner.timestamp_period = timestamp_period;
9860         self
9861     }
max_clip_distances( mut self, max_clip_distances: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9862     pub fn max_clip_distances(
9863         mut self,
9864         max_clip_distances: u32,
9865     ) -> PhysicalDeviceLimitsBuilder<'a> {
9866         self.inner.max_clip_distances = max_clip_distances;
9867         self
9868     }
max_cull_distances( mut self, max_cull_distances: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9869     pub fn max_cull_distances(
9870         mut self,
9871         max_cull_distances: u32,
9872     ) -> PhysicalDeviceLimitsBuilder<'a> {
9873         self.inner.max_cull_distances = max_cull_distances;
9874         self
9875     }
max_combined_clip_and_cull_distances( mut self, max_combined_clip_and_cull_distances: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9876     pub fn max_combined_clip_and_cull_distances(
9877         mut self,
9878         max_combined_clip_and_cull_distances: u32,
9879     ) -> PhysicalDeviceLimitsBuilder<'a> {
9880         self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances;
9881         self
9882     }
discrete_queue_priorities( mut self, discrete_queue_priorities: u32, ) -> PhysicalDeviceLimitsBuilder<'a>9883     pub fn discrete_queue_priorities(
9884         mut self,
9885         discrete_queue_priorities: u32,
9886     ) -> PhysicalDeviceLimitsBuilder<'a> {
9887         self.inner.discrete_queue_priorities = discrete_queue_priorities;
9888         self
9889     }
point_size_range( mut self, point_size_range: [f32; 2], ) -> PhysicalDeviceLimitsBuilder<'a>9890     pub fn point_size_range(
9891         mut self,
9892         point_size_range: [f32; 2],
9893     ) -> PhysicalDeviceLimitsBuilder<'a> {
9894         self.inner.point_size_range = point_size_range;
9895         self
9896     }
line_width_range( mut self, line_width_range: [f32; 2], ) -> PhysicalDeviceLimitsBuilder<'a>9897     pub fn line_width_range(
9898         mut self,
9899         line_width_range: [f32; 2],
9900     ) -> PhysicalDeviceLimitsBuilder<'a> {
9901         self.inner.line_width_range = line_width_range;
9902         self
9903     }
point_size_granularity( mut self, point_size_granularity: f32, ) -> PhysicalDeviceLimitsBuilder<'a>9904     pub fn point_size_granularity(
9905         mut self,
9906         point_size_granularity: f32,
9907     ) -> PhysicalDeviceLimitsBuilder<'a> {
9908         self.inner.point_size_granularity = point_size_granularity;
9909         self
9910     }
line_width_granularity( mut self, line_width_granularity: f32, ) -> PhysicalDeviceLimitsBuilder<'a>9911     pub fn line_width_granularity(
9912         mut self,
9913         line_width_granularity: f32,
9914     ) -> PhysicalDeviceLimitsBuilder<'a> {
9915         self.inner.line_width_granularity = line_width_granularity;
9916         self
9917     }
strict_lines(mut self, strict_lines: bool) -> PhysicalDeviceLimitsBuilder<'a>9918     pub fn strict_lines(mut self, strict_lines: bool) -> PhysicalDeviceLimitsBuilder<'a> {
9919         self.inner.strict_lines = strict_lines.into();
9920         self
9921     }
standard_sample_locations( mut self, standard_sample_locations: bool, ) -> PhysicalDeviceLimitsBuilder<'a>9922     pub fn standard_sample_locations(
9923         mut self,
9924         standard_sample_locations: bool,
9925     ) -> PhysicalDeviceLimitsBuilder<'a> {
9926         self.inner.standard_sample_locations = standard_sample_locations.into();
9927         self
9928     }
optimal_buffer_copy_offset_alignment( mut self, optimal_buffer_copy_offset_alignment: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9929     pub fn optimal_buffer_copy_offset_alignment(
9930         mut self,
9931         optimal_buffer_copy_offset_alignment: DeviceSize,
9932     ) -> PhysicalDeviceLimitsBuilder<'a> {
9933         self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment;
9934         self
9935     }
optimal_buffer_copy_row_pitch_alignment( mut self, optimal_buffer_copy_row_pitch_alignment: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9936     pub fn optimal_buffer_copy_row_pitch_alignment(
9937         mut self,
9938         optimal_buffer_copy_row_pitch_alignment: DeviceSize,
9939     ) -> PhysicalDeviceLimitsBuilder<'a> {
9940         self.inner.optimal_buffer_copy_row_pitch_alignment =
9941             optimal_buffer_copy_row_pitch_alignment;
9942         self
9943     }
non_coherent_atom_size( mut self, non_coherent_atom_size: DeviceSize, ) -> PhysicalDeviceLimitsBuilder<'a>9944     pub fn non_coherent_atom_size(
9945         mut self,
9946         non_coherent_atom_size: DeviceSize,
9947     ) -> PhysicalDeviceLimitsBuilder<'a> {
9948         self.inner.non_coherent_atom_size = non_coherent_atom_size;
9949         self
9950     }
9951     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
9952     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
9953     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLimits9954     pub fn build(self) -> PhysicalDeviceLimits {
9955         self.inner
9956     }
9957 }
9958 #[repr(C)]
9959 #[derive(Copy, Clone, Debug)]
9960 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateInfo.html>"]
9961 pub struct SemaphoreCreateInfo {
9962     pub s_type: StructureType,
9963     pub p_next: *const c_void,
9964     pub flags: SemaphoreCreateFlags,
9965 }
9966 impl ::std::default::Default for SemaphoreCreateInfo {
default() -> SemaphoreCreateInfo9967     fn default() -> SemaphoreCreateInfo {
9968         SemaphoreCreateInfo {
9969             s_type: StructureType::SEMAPHORE_CREATE_INFO,
9970             p_next: ::std::ptr::null(),
9971             flags: SemaphoreCreateFlags::default(),
9972         }
9973     }
9974 }
9975 impl SemaphoreCreateInfo {
builder<'a>() -> SemaphoreCreateInfoBuilder<'a>9976     pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> {
9977         SemaphoreCreateInfoBuilder {
9978             inner: SemaphoreCreateInfo::default(),
9979             marker: ::std::marker::PhantomData,
9980         }
9981     }
9982 }
9983 #[repr(transparent)]
9984 pub struct SemaphoreCreateInfoBuilder<'a> {
9985     inner: SemaphoreCreateInfo,
9986     marker: ::std::marker::PhantomData<&'a ()>,
9987 }
9988 pub unsafe trait ExtendsSemaphoreCreateInfo {}
9989 impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> {
9990     type Target = SemaphoreCreateInfo;
deref(&self) -> &Self::Target9991     fn deref(&self) -> &Self::Target {
9992         &self.inner
9993     }
9994 }
9995 impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target9996     fn deref_mut(&mut self) -> &mut Self::Target {
9997         &mut self.inner
9998     }
9999 }
10000 impl<'a> SemaphoreCreateInfoBuilder<'a> {
flags(mut self, flags: SemaphoreCreateFlags) -> SemaphoreCreateInfoBuilder<'a>10001     pub fn flags(mut self, flags: SemaphoreCreateFlags) -> SemaphoreCreateInfoBuilder<'a> {
10002         self.inner.flags = flags;
10003         self
10004     }
10005     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10006     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10007     #[doc = r" valid extension structs can be pushed into the chain."]
10008     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10009     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSemaphoreCreateInfo>( mut self, next: &'a mut T, ) -> SemaphoreCreateInfoBuilder<'a>10010     pub fn push_next<T: ExtendsSemaphoreCreateInfo>(
10011         mut self,
10012         next: &'a mut T,
10013     ) -> SemaphoreCreateInfoBuilder<'a> {
10014         unsafe {
10015             let next_ptr = next as *mut T as *mut BaseOutStructure;
10016             let last_next = ptr_chain_iter(next).last().unwrap();
10017             (*last_next).p_next = self.inner.p_next as _;
10018             self.inner.p_next = next_ptr as _;
10019         }
10020         self
10021     }
10022     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10023     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10024     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreCreateInfo10025     pub fn build(self) -> SemaphoreCreateInfo {
10026         self.inner
10027     }
10028 }
10029 #[repr(C)]
10030 #[derive(Copy, Clone, Debug)]
10031 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateInfo.html>"]
10032 pub struct QueryPoolCreateInfo {
10033     pub s_type: StructureType,
10034     pub p_next: *const c_void,
10035     pub flags: QueryPoolCreateFlags,
10036     pub query_type: QueryType,
10037     pub query_count: u32,
10038     pub pipeline_statistics: QueryPipelineStatisticFlags,
10039 }
10040 impl ::std::default::Default for QueryPoolCreateInfo {
default() -> QueryPoolCreateInfo10041     fn default() -> QueryPoolCreateInfo {
10042         QueryPoolCreateInfo {
10043             s_type: StructureType::QUERY_POOL_CREATE_INFO,
10044             p_next: ::std::ptr::null(),
10045             flags: QueryPoolCreateFlags::default(),
10046             query_type: QueryType::default(),
10047             query_count: u32::default(),
10048             pipeline_statistics: QueryPipelineStatisticFlags::default(),
10049         }
10050     }
10051 }
10052 impl QueryPoolCreateInfo {
builder<'a>() -> QueryPoolCreateInfoBuilder<'a>10053     pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> {
10054         QueryPoolCreateInfoBuilder {
10055             inner: QueryPoolCreateInfo::default(),
10056             marker: ::std::marker::PhantomData,
10057         }
10058     }
10059 }
10060 #[repr(transparent)]
10061 pub struct QueryPoolCreateInfoBuilder<'a> {
10062     inner: QueryPoolCreateInfo,
10063     marker: ::std::marker::PhantomData<&'a ()>,
10064 }
10065 pub unsafe trait ExtendsQueryPoolCreateInfo {}
10066 impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> {
10067     type Target = QueryPoolCreateInfo;
deref(&self) -> &Self::Target10068     fn deref(&self) -> &Self::Target {
10069         &self.inner
10070     }
10071 }
10072 impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10073     fn deref_mut(&mut self) -> &mut Self::Target {
10074         &mut self.inner
10075     }
10076 }
10077 impl<'a> QueryPoolCreateInfoBuilder<'a> {
flags(mut self, flags: QueryPoolCreateFlags) -> QueryPoolCreateInfoBuilder<'a>10078     pub fn flags(mut self, flags: QueryPoolCreateFlags) -> QueryPoolCreateInfoBuilder<'a> {
10079         self.inner.flags = flags;
10080         self
10081     }
query_type(mut self, query_type: QueryType) -> QueryPoolCreateInfoBuilder<'a>10082     pub fn query_type(mut self, query_type: QueryType) -> QueryPoolCreateInfoBuilder<'a> {
10083         self.inner.query_type = query_type;
10084         self
10085     }
query_count(mut self, query_count: u32) -> QueryPoolCreateInfoBuilder<'a>10086     pub fn query_count(mut self, query_count: u32) -> QueryPoolCreateInfoBuilder<'a> {
10087         self.inner.query_count = query_count;
10088         self
10089     }
pipeline_statistics( mut self, pipeline_statistics: QueryPipelineStatisticFlags, ) -> QueryPoolCreateInfoBuilder<'a>10090     pub fn pipeline_statistics(
10091         mut self,
10092         pipeline_statistics: QueryPipelineStatisticFlags,
10093     ) -> QueryPoolCreateInfoBuilder<'a> {
10094         self.inner.pipeline_statistics = pipeline_statistics;
10095         self
10096     }
10097     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10098     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10099     #[doc = r" valid extension structs can be pushed into the chain."]
10100     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10101     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsQueryPoolCreateInfo>( mut self, next: &'a mut T, ) -> QueryPoolCreateInfoBuilder<'a>10102     pub fn push_next<T: ExtendsQueryPoolCreateInfo>(
10103         mut self,
10104         next: &'a mut T,
10105     ) -> QueryPoolCreateInfoBuilder<'a> {
10106         unsafe {
10107             let next_ptr = next as *mut T as *mut BaseOutStructure;
10108             let last_next = ptr_chain_iter(next).last().unwrap();
10109             (*last_next).p_next = self.inner.p_next as _;
10110             self.inner.p_next = next_ptr as _;
10111         }
10112         self
10113     }
10114     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10115     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10116     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueryPoolCreateInfo10117     pub fn build(self) -> QueryPoolCreateInfo {
10118         self.inner
10119     }
10120 }
10121 #[repr(C)]
10122 #[derive(Copy, Clone, Debug)]
10123 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateInfo.html>"]
10124 pub struct FramebufferCreateInfo {
10125     pub s_type: StructureType,
10126     pub p_next: *const c_void,
10127     pub flags: FramebufferCreateFlags,
10128     pub render_pass: RenderPass,
10129     pub attachment_count: u32,
10130     pub p_attachments: *const ImageView,
10131     pub width: u32,
10132     pub height: u32,
10133     pub layers: u32,
10134 }
10135 impl ::std::default::Default for FramebufferCreateInfo {
default() -> FramebufferCreateInfo10136     fn default() -> FramebufferCreateInfo {
10137         FramebufferCreateInfo {
10138             s_type: StructureType::FRAMEBUFFER_CREATE_INFO,
10139             p_next: ::std::ptr::null(),
10140             flags: FramebufferCreateFlags::default(),
10141             render_pass: RenderPass::default(),
10142             attachment_count: u32::default(),
10143             p_attachments: ::std::ptr::null(),
10144             width: u32::default(),
10145             height: u32::default(),
10146             layers: u32::default(),
10147         }
10148     }
10149 }
10150 impl FramebufferCreateInfo {
builder<'a>() -> FramebufferCreateInfoBuilder<'a>10151     pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> {
10152         FramebufferCreateInfoBuilder {
10153             inner: FramebufferCreateInfo::default(),
10154             marker: ::std::marker::PhantomData,
10155         }
10156     }
10157 }
10158 #[repr(transparent)]
10159 pub struct FramebufferCreateInfoBuilder<'a> {
10160     inner: FramebufferCreateInfo,
10161     marker: ::std::marker::PhantomData<&'a ()>,
10162 }
10163 pub unsafe trait ExtendsFramebufferCreateInfo {}
10164 impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> {
10165     type Target = FramebufferCreateInfo;
deref(&self) -> &Self::Target10166     fn deref(&self) -> &Self::Target {
10167         &self.inner
10168     }
10169 }
10170 impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10171     fn deref_mut(&mut self) -> &mut Self::Target {
10172         &mut self.inner
10173     }
10174 }
10175 impl<'a> FramebufferCreateInfoBuilder<'a> {
flags(mut self, flags: FramebufferCreateFlags) -> FramebufferCreateInfoBuilder<'a>10176     pub fn flags(mut self, flags: FramebufferCreateFlags) -> FramebufferCreateInfoBuilder<'a> {
10177         self.inner.flags = flags;
10178         self
10179     }
render_pass(mut self, render_pass: RenderPass) -> FramebufferCreateInfoBuilder<'a>10180     pub fn render_pass(mut self, render_pass: RenderPass) -> FramebufferCreateInfoBuilder<'a> {
10181         self.inner.render_pass = render_pass;
10182         self
10183     }
attachments(mut self, attachments: &'a [ImageView]) -> FramebufferCreateInfoBuilder<'a>10184     pub fn attachments(mut self, attachments: &'a [ImageView]) -> FramebufferCreateInfoBuilder<'a> {
10185         self.inner.attachment_count = attachments.len() as _;
10186         self.inner.p_attachments = attachments.as_ptr();
10187         self
10188     }
width(mut self, width: u32) -> FramebufferCreateInfoBuilder<'a>10189     pub fn width(mut self, width: u32) -> FramebufferCreateInfoBuilder<'a> {
10190         self.inner.width = width;
10191         self
10192     }
height(mut self, height: u32) -> FramebufferCreateInfoBuilder<'a>10193     pub fn height(mut self, height: u32) -> FramebufferCreateInfoBuilder<'a> {
10194         self.inner.height = height;
10195         self
10196     }
layers(mut self, layers: u32) -> FramebufferCreateInfoBuilder<'a>10197     pub fn layers(mut self, layers: u32) -> FramebufferCreateInfoBuilder<'a> {
10198         self.inner.layers = layers;
10199         self
10200     }
10201     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10202     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10203     #[doc = r" valid extension structs can be pushed into the chain."]
10204     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10205     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFramebufferCreateInfo>( mut self, next: &'a mut T, ) -> FramebufferCreateInfoBuilder<'a>10206     pub fn push_next<T: ExtendsFramebufferCreateInfo>(
10207         mut self,
10208         next: &'a mut T,
10209     ) -> FramebufferCreateInfoBuilder<'a> {
10210         unsafe {
10211             let next_ptr = next as *mut T as *mut BaseOutStructure;
10212             let last_next = ptr_chain_iter(next).last().unwrap();
10213             (*last_next).p_next = self.inner.p_next as _;
10214             self.inner.p_next = next_ptr as _;
10215         }
10216         self
10217     }
10218     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10219     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10220     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferCreateInfo10221     pub fn build(self) -> FramebufferCreateInfo {
10222         self.inner
10223     }
10224 }
10225 #[repr(C)]
10226 #[derive(Copy, Clone, Default, Debug)]
10227 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawIndirectCommand.html>"]
10228 pub struct DrawIndirectCommand {
10229     pub vertex_count: u32,
10230     pub instance_count: u32,
10231     pub first_vertex: u32,
10232     pub first_instance: u32,
10233 }
10234 impl DrawIndirectCommand {
builder<'a>() -> DrawIndirectCommandBuilder<'a>10235     pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> {
10236         DrawIndirectCommandBuilder {
10237             inner: DrawIndirectCommand::default(),
10238             marker: ::std::marker::PhantomData,
10239         }
10240     }
10241 }
10242 #[repr(transparent)]
10243 pub struct DrawIndirectCommandBuilder<'a> {
10244     inner: DrawIndirectCommand,
10245     marker: ::std::marker::PhantomData<&'a ()>,
10246 }
10247 impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> {
10248     type Target = DrawIndirectCommand;
deref(&self) -> &Self::Target10249     fn deref(&self) -> &Self::Target {
10250         &self.inner
10251     }
10252 }
10253 impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10254     fn deref_mut(&mut self) -> &mut Self::Target {
10255         &mut self.inner
10256     }
10257 }
10258 impl<'a> DrawIndirectCommandBuilder<'a> {
vertex_count(mut self, vertex_count: u32) -> DrawIndirectCommandBuilder<'a>10259     pub fn vertex_count(mut self, vertex_count: u32) -> DrawIndirectCommandBuilder<'a> {
10260         self.inner.vertex_count = vertex_count;
10261         self
10262     }
instance_count(mut self, instance_count: u32) -> DrawIndirectCommandBuilder<'a>10263     pub fn instance_count(mut self, instance_count: u32) -> DrawIndirectCommandBuilder<'a> {
10264         self.inner.instance_count = instance_count;
10265         self
10266     }
first_vertex(mut self, first_vertex: u32) -> DrawIndirectCommandBuilder<'a>10267     pub fn first_vertex(mut self, first_vertex: u32) -> DrawIndirectCommandBuilder<'a> {
10268         self.inner.first_vertex = first_vertex;
10269         self
10270     }
first_instance(mut self, first_instance: u32) -> DrawIndirectCommandBuilder<'a>10271     pub fn first_instance(mut self, first_instance: u32) -> DrawIndirectCommandBuilder<'a> {
10272         self.inner.first_instance = first_instance;
10273         self
10274     }
10275     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10276     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10277     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrawIndirectCommand10278     pub fn build(self) -> DrawIndirectCommand {
10279         self.inner
10280     }
10281 }
10282 #[repr(C)]
10283 #[derive(Copy, Clone, Default, Debug)]
10284 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawIndexedIndirectCommand.html>"]
10285 pub struct DrawIndexedIndirectCommand {
10286     pub index_count: u32,
10287     pub instance_count: u32,
10288     pub first_index: u32,
10289     pub vertex_offset: i32,
10290     pub first_instance: u32,
10291 }
10292 impl DrawIndexedIndirectCommand {
builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a>10293     pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> {
10294         DrawIndexedIndirectCommandBuilder {
10295             inner: DrawIndexedIndirectCommand::default(),
10296             marker: ::std::marker::PhantomData,
10297         }
10298     }
10299 }
10300 #[repr(transparent)]
10301 pub struct DrawIndexedIndirectCommandBuilder<'a> {
10302     inner: DrawIndexedIndirectCommand,
10303     marker: ::std::marker::PhantomData<&'a ()>,
10304 }
10305 impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> {
10306     type Target = DrawIndexedIndirectCommand;
deref(&self) -> &Self::Target10307     fn deref(&self) -> &Self::Target {
10308         &self.inner
10309     }
10310 }
10311 impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10312     fn deref_mut(&mut self) -> &mut Self::Target {
10313         &mut self.inner
10314     }
10315 }
10316 impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
index_count(mut self, index_count: u32) -> DrawIndexedIndirectCommandBuilder<'a>10317     pub fn index_count(mut self, index_count: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
10318         self.inner.index_count = index_count;
10319         self
10320     }
instance_count(mut self, instance_count: u32) -> DrawIndexedIndirectCommandBuilder<'a>10321     pub fn instance_count(mut self, instance_count: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
10322         self.inner.instance_count = instance_count;
10323         self
10324     }
first_index(mut self, first_index: u32) -> DrawIndexedIndirectCommandBuilder<'a>10325     pub fn first_index(mut self, first_index: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
10326         self.inner.first_index = first_index;
10327         self
10328     }
vertex_offset(mut self, vertex_offset: i32) -> DrawIndexedIndirectCommandBuilder<'a>10329     pub fn vertex_offset(mut self, vertex_offset: i32) -> DrawIndexedIndirectCommandBuilder<'a> {
10330         self.inner.vertex_offset = vertex_offset;
10331         self
10332     }
first_instance(mut self, first_instance: u32) -> DrawIndexedIndirectCommandBuilder<'a>10333     pub fn first_instance(mut self, first_instance: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
10334         self.inner.first_instance = first_instance;
10335         self
10336     }
10337     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10338     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10339     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrawIndexedIndirectCommand10340     pub fn build(self) -> DrawIndexedIndirectCommand {
10341         self.inner
10342     }
10343 }
10344 #[repr(C)]
10345 #[derive(Copy, Clone, Default, Debug)]
10346 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDispatchIndirectCommand.html>"]
10347 pub struct DispatchIndirectCommand {
10348     pub x: u32,
10349     pub y: u32,
10350     pub z: u32,
10351 }
10352 impl DispatchIndirectCommand {
builder<'a>() -> DispatchIndirectCommandBuilder<'a>10353     pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> {
10354         DispatchIndirectCommandBuilder {
10355             inner: DispatchIndirectCommand::default(),
10356             marker: ::std::marker::PhantomData,
10357         }
10358     }
10359 }
10360 #[repr(transparent)]
10361 pub struct DispatchIndirectCommandBuilder<'a> {
10362     inner: DispatchIndirectCommand,
10363     marker: ::std::marker::PhantomData<&'a ()>,
10364 }
10365 impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> {
10366     type Target = DispatchIndirectCommand;
deref(&self) -> &Self::Target10367     fn deref(&self) -> &Self::Target {
10368         &self.inner
10369     }
10370 }
10371 impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10372     fn deref_mut(&mut self) -> &mut Self::Target {
10373         &mut self.inner
10374     }
10375 }
10376 impl<'a> DispatchIndirectCommandBuilder<'a> {
x(mut self, x: u32) -> DispatchIndirectCommandBuilder<'a>10377     pub fn x(mut self, x: u32) -> DispatchIndirectCommandBuilder<'a> {
10378         self.inner.x = x;
10379         self
10380     }
y(mut self, y: u32) -> DispatchIndirectCommandBuilder<'a>10381     pub fn y(mut self, y: u32) -> DispatchIndirectCommandBuilder<'a> {
10382         self.inner.y = y;
10383         self
10384     }
z(mut self, z: u32) -> DispatchIndirectCommandBuilder<'a>10385     pub fn z(mut self, z: u32) -> DispatchIndirectCommandBuilder<'a> {
10386         self.inner.z = z;
10387         self
10388     }
10389     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10390     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10391     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DispatchIndirectCommand10392     pub fn build(self) -> DispatchIndirectCommand {
10393         self.inner
10394     }
10395 }
10396 #[repr(C)]
10397 #[derive(Copy, Clone, Debug)]
10398 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitInfo.html>"]
10399 pub struct SubmitInfo {
10400     pub s_type: StructureType,
10401     pub p_next: *const c_void,
10402     pub wait_semaphore_count: u32,
10403     pub p_wait_semaphores: *const Semaphore,
10404     pub p_wait_dst_stage_mask: *const PipelineStageFlags,
10405     pub command_buffer_count: u32,
10406     pub p_command_buffers: *const CommandBuffer,
10407     pub signal_semaphore_count: u32,
10408     pub p_signal_semaphores: *const Semaphore,
10409 }
10410 impl ::std::default::Default for SubmitInfo {
default() -> SubmitInfo10411     fn default() -> SubmitInfo {
10412         SubmitInfo {
10413             s_type: StructureType::SUBMIT_INFO,
10414             p_next: ::std::ptr::null(),
10415             wait_semaphore_count: u32::default(),
10416             p_wait_semaphores: ::std::ptr::null(),
10417             p_wait_dst_stage_mask: ::std::ptr::null(),
10418             command_buffer_count: u32::default(),
10419             p_command_buffers: ::std::ptr::null(),
10420             signal_semaphore_count: u32::default(),
10421             p_signal_semaphores: ::std::ptr::null(),
10422         }
10423     }
10424 }
10425 impl SubmitInfo {
builder<'a>() -> SubmitInfoBuilder<'a>10426     pub fn builder<'a>() -> SubmitInfoBuilder<'a> {
10427         SubmitInfoBuilder {
10428             inner: SubmitInfo::default(),
10429             marker: ::std::marker::PhantomData,
10430         }
10431     }
10432 }
10433 #[repr(transparent)]
10434 pub struct SubmitInfoBuilder<'a> {
10435     inner: SubmitInfo,
10436     marker: ::std::marker::PhantomData<&'a ()>,
10437 }
10438 pub unsafe trait ExtendsSubmitInfo {}
10439 impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> {
10440     type Target = SubmitInfo;
deref(&self) -> &Self::Target10441     fn deref(&self) -> &Self::Target {
10442         &self.inner
10443     }
10444 }
10445 impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10446     fn deref_mut(&mut self) -> &mut Self::Target {
10447         &mut self.inner
10448     }
10449 }
10450 impl<'a> SubmitInfoBuilder<'a> {
wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> SubmitInfoBuilder<'a>10451     pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> SubmitInfoBuilder<'a> {
10452         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
10453         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
10454         self
10455     }
wait_dst_stage_mask( mut self, wait_dst_stage_mask: &'a [PipelineStageFlags], ) -> SubmitInfoBuilder<'a>10456     pub fn wait_dst_stage_mask(
10457         mut self,
10458         wait_dst_stage_mask: &'a [PipelineStageFlags],
10459     ) -> SubmitInfoBuilder<'a> {
10460         self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _;
10461         self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr();
10462         self
10463     }
command_buffers( mut self, command_buffers: &'a [CommandBuffer], ) -> SubmitInfoBuilder<'a>10464     pub fn command_buffers(
10465         mut self,
10466         command_buffers: &'a [CommandBuffer],
10467     ) -> SubmitInfoBuilder<'a> {
10468         self.inner.command_buffer_count = command_buffers.len() as _;
10469         self.inner.p_command_buffers = command_buffers.as_ptr();
10470         self
10471     }
signal_semaphores( mut self, signal_semaphores: &'a [Semaphore], ) -> SubmitInfoBuilder<'a>10472     pub fn signal_semaphores(
10473         mut self,
10474         signal_semaphores: &'a [Semaphore],
10475     ) -> SubmitInfoBuilder<'a> {
10476         self.inner.signal_semaphore_count = signal_semaphores.len() as _;
10477         self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
10478         self
10479     }
10480     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10481     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10482     #[doc = r" valid extension structs can be pushed into the chain."]
10483     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10484     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> SubmitInfoBuilder<'a>10485     pub fn push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> SubmitInfoBuilder<'a> {
10486         unsafe {
10487             let next_ptr = next as *mut T as *mut BaseOutStructure;
10488             let last_next = ptr_chain_iter(next).last().unwrap();
10489             (*last_next).p_next = self.inner.p_next as _;
10490             self.inner.p_next = next_ptr as _;
10491         }
10492         self
10493     }
10494     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10495     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10496     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubmitInfo10497     pub fn build(self) -> SubmitInfo {
10498         self.inner
10499     }
10500 }
10501 #[repr(C)]
10502 #[derive(Copy, Clone, Debug)]
10503 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPropertiesKHR.html>"]
10504 pub struct DisplayPropertiesKHR {
10505     pub display: DisplayKHR,
10506     pub display_name: *const c_char,
10507     pub physical_dimensions: Extent2D,
10508     pub physical_resolution: Extent2D,
10509     pub supported_transforms: SurfaceTransformFlagsKHR,
10510     pub plane_reorder_possible: Bool32,
10511     pub persistent_content: Bool32,
10512 }
10513 impl ::std::default::Default for DisplayPropertiesKHR {
default() -> DisplayPropertiesKHR10514     fn default() -> DisplayPropertiesKHR {
10515         DisplayPropertiesKHR {
10516             display: DisplayKHR::default(),
10517             display_name: ::std::ptr::null(),
10518             physical_dimensions: Extent2D::default(),
10519             physical_resolution: Extent2D::default(),
10520             supported_transforms: SurfaceTransformFlagsKHR::default(),
10521             plane_reorder_possible: Bool32::default(),
10522             persistent_content: Bool32::default(),
10523         }
10524     }
10525 }
10526 impl DisplayPropertiesKHR {
builder<'a>() -> DisplayPropertiesKHRBuilder<'a>10527     pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> {
10528         DisplayPropertiesKHRBuilder {
10529             inner: DisplayPropertiesKHR::default(),
10530             marker: ::std::marker::PhantomData,
10531         }
10532     }
10533 }
10534 #[repr(transparent)]
10535 pub struct DisplayPropertiesKHRBuilder<'a> {
10536     inner: DisplayPropertiesKHR,
10537     marker: ::std::marker::PhantomData<&'a ()>,
10538 }
10539 impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> {
10540     type Target = DisplayPropertiesKHR;
deref(&self) -> &Self::Target10541     fn deref(&self) -> &Self::Target {
10542         &self.inner
10543     }
10544 }
10545 impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10546     fn deref_mut(&mut self) -> &mut Self::Target {
10547         &mut self.inner
10548     }
10549 }
10550 impl<'a> DisplayPropertiesKHRBuilder<'a> {
display(mut self, display: DisplayKHR) -> DisplayPropertiesKHRBuilder<'a>10551     pub fn display(mut self, display: DisplayKHR) -> DisplayPropertiesKHRBuilder<'a> {
10552         self.inner.display = display;
10553         self
10554     }
display_name( mut self, display_name: &'a ::std::ffi::CStr, ) -> DisplayPropertiesKHRBuilder<'a>10555     pub fn display_name(
10556         mut self,
10557         display_name: &'a ::std::ffi::CStr,
10558     ) -> DisplayPropertiesKHRBuilder<'a> {
10559         self.inner.display_name = display_name.as_ptr();
10560         self
10561     }
physical_dimensions( mut self, physical_dimensions: Extent2D, ) -> DisplayPropertiesKHRBuilder<'a>10562     pub fn physical_dimensions(
10563         mut self,
10564         physical_dimensions: Extent2D,
10565     ) -> DisplayPropertiesKHRBuilder<'a> {
10566         self.inner.physical_dimensions = physical_dimensions;
10567         self
10568     }
physical_resolution( mut self, physical_resolution: Extent2D, ) -> DisplayPropertiesKHRBuilder<'a>10569     pub fn physical_resolution(
10570         mut self,
10571         physical_resolution: Extent2D,
10572     ) -> DisplayPropertiesKHRBuilder<'a> {
10573         self.inner.physical_resolution = physical_resolution;
10574         self
10575     }
supported_transforms( mut self, supported_transforms: SurfaceTransformFlagsKHR, ) -> DisplayPropertiesKHRBuilder<'a>10576     pub fn supported_transforms(
10577         mut self,
10578         supported_transforms: SurfaceTransformFlagsKHR,
10579     ) -> DisplayPropertiesKHRBuilder<'a> {
10580         self.inner.supported_transforms = supported_transforms;
10581         self
10582     }
plane_reorder_possible( mut self, plane_reorder_possible: bool, ) -> DisplayPropertiesKHRBuilder<'a>10583     pub fn plane_reorder_possible(
10584         mut self,
10585         plane_reorder_possible: bool,
10586     ) -> DisplayPropertiesKHRBuilder<'a> {
10587         self.inner.plane_reorder_possible = plane_reorder_possible.into();
10588         self
10589     }
persistent_content( mut self, persistent_content: bool, ) -> DisplayPropertiesKHRBuilder<'a>10590     pub fn persistent_content(
10591         mut self,
10592         persistent_content: bool,
10593     ) -> DisplayPropertiesKHRBuilder<'a> {
10594         self.inner.persistent_content = persistent_content.into();
10595         self
10596     }
10597     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10598     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10599     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPropertiesKHR10600     pub fn build(self) -> DisplayPropertiesKHR {
10601         self.inner
10602     }
10603 }
10604 #[repr(C)]
10605 #[derive(Copy, Clone, Default, Debug)]
10606 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlanePropertiesKHR.html>"]
10607 pub struct DisplayPlanePropertiesKHR {
10608     pub current_display: DisplayKHR,
10609     pub current_stack_index: u32,
10610 }
10611 impl DisplayPlanePropertiesKHR {
builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a>10612     pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> {
10613         DisplayPlanePropertiesKHRBuilder {
10614             inner: DisplayPlanePropertiesKHR::default(),
10615             marker: ::std::marker::PhantomData,
10616         }
10617     }
10618 }
10619 #[repr(transparent)]
10620 pub struct DisplayPlanePropertiesKHRBuilder<'a> {
10621     inner: DisplayPlanePropertiesKHR,
10622     marker: ::std::marker::PhantomData<&'a ()>,
10623 }
10624 impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> {
10625     type Target = DisplayPlanePropertiesKHR;
deref(&self) -> &Self::Target10626     fn deref(&self) -> &Self::Target {
10627         &self.inner
10628     }
10629 }
10630 impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10631     fn deref_mut(&mut self) -> &mut Self::Target {
10632         &mut self.inner
10633     }
10634 }
10635 impl<'a> DisplayPlanePropertiesKHRBuilder<'a> {
current_display( mut self, current_display: DisplayKHR, ) -> DisplayPlanePropertiesKHRBuilder<'a>10636     pub fn current_display(
10637         mut self,
10638         current_display: DisplayKHR,
10639     ) -> DisplayPlanePropertiesKHRBuilder<'a> {
10640         self.inner.current_display = current_display;
10641         self
10642     }
current_stack_index( mut self, current_stack_index: u32, ) -> DisplayPlanePropertiesKHRBuilder<'a>10643     pub fn current_stack_index(
10644         mut self,
10645         current_stack_index: u32,
10646     ) -> DisplayPlanePropertiesKHRBuilder<'a> {
10647         self.inner.current_stack_index = current_stack_index;
10648         self
10649     }
10650     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10651     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10652     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlanePropertiesKHR10653     pub fn build(self) -> DisplayPlanePropertiesKHR {
10654         self.inner
10655     }
10656 }
10657 #[repr(C)]
10658 #[derive(Copy, Clone, Default, Debug)]
10659 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeParametersKHR.html>"]
10660 pub struct DisplayModeParametersKHR {
10661     pub visible_region: Extent2D,
10662     pub refresh_rate: u32,
10663 }
10664 impl DisplayModeParametersKHR {
builder<'a>() -> DisplayModeParametersKHRBuilder<'a>10665     pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> {
10666         DisplayModeParametersKHRBuilder {
10667             inner: DisplayModeParametersKHR::default(),
10668             marker: ::std::marker::PhantomData,
10669         }
10670     }
10671 }
10672 #[repr(transparent)]
10673 pub struct DisplayModeParametersKHRBuilder<'a> {
10674     inner: DisplayModeParametersKHR,
10675     marker: ::std::marker::PhantomData<&'a ()>,
10676 }
10677 impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> {
10678     type Target = DisplayModeParametersKHR;
deref(&self) -> &Self::Target10679     fn deref(&self) -> &Self::Target {
10680         &self.inner
10681     }
10682 }
10683 impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10684     fn deref_mut(&mut self) -> &mut Self::Target {
10685         &mut self.inner
10686     }
10687 }
10688 impl<'a> DisplayModeParametersKHRBuilder<'a> {
visible_region( mut self, visible_region: Extent2D, ) -> DisplayModeParametersKHRBuilder<'a>10689     pub fn visible_region(
10690         mut self,
10691         visible_region: Extent2D,
10692     ) -> DisplayModeParametersKHRBuilder<'a> {
10693         self.inner.visible_region = visible_region;
10694         self
10695     }
refresh_rate(mut self, refresh_rate: u32) -> DisplayModeParametersKHRBuilder<'a>10696     pub fn refresh_rate(mut self, refresh_rate: u32) -> DisplayModeParametersKHRBuilder<'a> {
10697         self.inner.refresh_rate = refresh_rate;
10698         self
10699     }
10700     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10701     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10702     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModeParametersKHR10703     pub fn build(self) -> DisplayModeParametersKHR {
10704         self.inner
10705     }
10706 }
10707 #[repr(C)]
10708 #[derive(Copy, Clone, Default, Debug)]
10709 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModePropertiesKHR.html>"]
10710 pub struct DisplayModePropertiesKHR {
10711     pub display_mode: DisplayModeKHR,
10712     pub parameters: DisplayModeParametersKHR,
10713 }
10714 impl DisplayModePropertiesKHR {
builder<'a>() -> DisplayModePropertiesKHRBuilder<'a>10715     pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> {
10716         DisplayModePropertiesKHRBuilder {
10717             inner: DisplayModePropertiesKHR::default(),
10718             marker: ::std::marker::PhantomData,
10719         }
10720     }
10721 }
10722 #[repr(transparent)]
10723 pub struct DisplayModePropertiesKHRBuilder<'a> {
10724     inner: DisplayModePropertiesKHR,
10725     marker: ::std::marker::PhantomData<&'a ()>,
10726 }
10727 impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> {
10728     type Target = DisplayModePropertiesKHR;
deref(&self) -> &Self::Target10729     fn deref(&self) -> &Self::Target {
10730         &self.inner
10731     }
10732 }
10733 impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10734     fn deref_mut(&mut self) -> &mut Self::Target {
10735         &mut self.inner
10736     }
10737 }
10738 impl<'a> DisplayModePropertiesKHRBuilder<'a> {
display_mode( mut self, display_mode: DisplayModeKHR, ) -> DisplayModePropertiesKHRBuilder<'a>10739     pub fn display_mode(
10740         mut self,
10741         display_mode: DisplayModeKHR,
10742     ) -> DisplayModePropertiesKHRBuilder<'a> {
10743         self.inner.display_mode = display_mode;
10744         self
10745     }
parameters( mut self, parameters: DisplayModeParametersKHR, ) -> DisplayModePropertiesKHRBuilder<'a>10746     pub fn parameters(
10747         mut self,
10748         parameters: DisplayModeParametersKHR,
10749     ) -> DisplayModePropertiesKHRBuilder<'a> {
10750         self.inner.parameters = parameters;
10751         self
10752     }
10753     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10754     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10755     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModePropertiesKHR10756     pub fn build(self) -> DisplayModePropertiesKHR {
10757         self.inner
10758     }
10759 }
10760 #[repr(C)]
10761 #[derive(Copy, Clone, Debug)]
10762 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateInfoKHR.html>"]
10763 pub struct DisplayModeCreateInfoKHR {
10764     pub s_type: StructureType,
10765     pub p_next: *const c_void,
10766     pub flags: DisplayModeCreateFlagsKHR,
10767     pub parameters: DisplayModeParametersKHR,
10768 }
10769 impl ::std::default::Default for DisplayModeCreateInfoKHR {
default() -> DisplayModeCreateInfoKHR10770     fn default() -> DisplayModeCreateInfoKHR {
10771         DisplayModeCreateInfoKHR {
10772             s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR,
10773             p_next: ::std::ptr::null(),
10774             flags: DisplayModeCreateFlagsKHR::default(),
10775             parameters: DisplayModeParametersKHR::default(),
10776         }
10777     }
10778 }
10779 impl DisplayModeCreateInfoKHR {
builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a>10780     pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> {
10781         DisplayModeCreateInfoKHRBuilder {
10782             inner: DisplayModeCreateInfoKHR::default(),
10783             marker: ::std::marker::PhantomData,
10784         }
10785     }
10786 }
10787 #[repr(transparent)]
10788 pub struct DisplayModeCreateInfoKHRBuilder<'a> {
10789     inner: DisplayModeCreateInfoKHR,
10790     marker: ::std::marker::PhantomData<&'a ()>,
10791 }
10792 pub unsafe trait ExtendsDisplayModeCreateInfoKHR {}
10793 impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> {
10794     type Target = DisplayModeCreateInfoKHR;
deref(&self) -> &Self::Target10795     fn deref(&self) -> &Self::Target {
10796         &self.inner
10797     }
10798 }
10799 impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10800     fn deref_mut(&mut self) -> &mut Self::Target {
10801         &mut self.inner
10802     }
10803 }
10804 impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
flags( mut self, flags: DisplayModeCreateFlagsKHR, ) -> DisplayModeCreateInfoKHRBuilder<'a>10805     pub fn flags(
10806         mut self,
10807         flags: DisplayModeCreateFlagsKHR,
10808     ) -> DisplayModeCreateInfoKHRBuilder<'a> {
10809         self.inner.flags = flags;
10810         self
10811     }
parameters( mut self, parameters: DisplayModeParametersKHR, ) -> DisplayModeCreateInfoKHRBuilder<'a>10812     pub fn parameters(
10813         mut self,
10814         parameters: DisplayModeParametersKHR,
10815     ) -> DisplayModeCreateInfoKHRBuilder<'a> {
10816         self.inner.parameters = parameters;
10817         self
10818     }
10819     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
10820     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
10821     #[doc = r" valid extension structs can be pushed into the chain."]
10822     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
10823     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayModeCreateInfoKHR>( mut self, next: &'a mut T, ) -> DisplayModeCreateInfoKHRBuilder<'a>10824     pub fn push_next<T: ExtendsDisplayModeCreateInfoKHR>(
10825         mut self,
10826         next: &'a mut T,
10827     ) -> DisplayModeCreateInfoKHRBuilder<'a> {
10828         unsafe {
10829             let next_ptr = next as *mut T as *mut BaseOutStructure;
10830             let last_next = ptr_chain_iter(next).last().unwrap();
10831             (*last_next).p_next = self.inner.p_next as _;
10832             self.inner.p_next = next_ptr as _;
10833         }
10834         self
10835     }
10836     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10837     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10838     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModeCreateInfoKHR10839     pub fn build(self) -> DisplayModeCreateInfoKHR {
10840         self.inner
10841     }
10842 }
10843 #[repr(C)]
10844 #[derive(Copy, Clone, Default, Debug)]
10845 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html>"]
10846 pub struct DisplayPlaneCapabilitiesKHR {
10847     pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
10848     pub min_src_position: Offset2D,
10849     pub max_src_position: Offset2D,
10850     pub min_src_extent: Extent2D,
10851     pub max_src_extent: Extent2D,
10852     pub min_dst_position: Offset2D,
10853     pub max_dst_position: Offset2D,
10854     pub min_dst_extent: Extent2D,
10855     pub max_dst_extent: Extent2D,
10856 }
10857 impl DisplayPlaneCapabilitiesKHR {
builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a>10858     pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10859         DisplayPlaneCapabilitiesKHRBuilder {
10860             inner: DisplayPlaneCapabilitiesKHR::default(),
10861             marker: ::std::marker::PhantomData,
10862         }
10863     }
10864 }
10865 #[repr(transparent)]
10866 pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> {
10867     inner: DisplayPlaneCapabilitiesKHR,
10868     marker: ::std::marker::PhantomData<&'a ()>,
10869 }
10870 impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> {
10871     type Target = DisplayPlaneCapabilitiesKHR;
deref(&self) -> &Self::Target10872     fn deref(&self) -> &Self::Target {
10873         &self.inner
10874     }
10875 }
10876 impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target10877     fn deref_mut(&mut self) -> &mut Self::Target {
10878         &mut self.inner
10879     }
10880 }
10881 impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> {
supported_alpha( mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10882     pub fn supported_alpha(
10883         mut self,
10884         supported_alpha: DisplayPlaneAlphaFlagsKHR,
10885     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10886         self.inner.supported_alpha = supported_alpha;
10887         self
10888     }
min_src_position( mut self, min_src_position: Offset2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10889     pub fn min_src_position(
10890         mut self,
10891         min_src_position: Offset2D,
10892     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10893         self.inner.min_src_position = min_src_position;
10894         self
10895     }
max_src_position( mut self, max_src_position: Offset2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10896     pub fn max_src_position(
10897         mut self,
10898         max_src_position: Offset2D,
10899     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10900         self.inner.max_src_position = max_src_position;
10901         self
10902     }
min_src_extent( mut self, min_src_extent: Extent2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10903     pub fn min_src_extent(
10904         mut self,
10905         min_src_extent: Extent2D,
10906     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10907         self.inner.min_src_extent = min_src_extent;
10908         self
10909     }
max_src_extent( mut self, max_src_extent: Extent2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10910     pub fn max_src_extent(
10911         mut self,
10912         max_src_extent: Extent2D,
10913     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10914         self.inner.max_src_extent = max_src_extent;
10915         self
10916     }
min_dst_position( mut self, min_dst_position: Offset2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10917     pub fn min_dst_position(
10918         mut self,
10919         min_dst_position: Offset2D,
10920     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10921         self.inner.min_dst_position = min_dst_position;
10922         self
10923     }
max_dst_position( mut self, max_dst_position: Offset2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10924     pub fn max_dst_position(
10925         mut self,
10926         max_dst_position: Offset2D,
10927     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10928         self.inner.max_dst_position = max_dst_position;
10929         self
10930     }
min_dst_extent( mut self, min_dst_extent: Extent2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10931     pub fn min_dst_extent(
10932         mut self,
10933         min_dst_extent: Extent2D,
10934     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10935         self.inner.min_dst_extent = min_dst_extent;
10936         self
10937     }
max_dst_extent( mut self, max_dst_extent: Extent2D, ) -> DisplayPlaneCapabilitiesKHRBuilder<'a>10938     pub fn max_dst_extent(
10939         mut self,
10940         max_dst_extent: Extent2D,
10941     ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
10942         self.inner.max_dst_extent = max_dst_extent;
10943         self
10944     }
10945     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
10946     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
10947     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneCapabilitiesKHR10948     pub fn build(self) -> DisplayPlaneCapabilitiesKHR {
10949         self.inner
10950     }
10951 }
10952 #[repr(C)]
10953 #[derive(Copy, Clone, Debug)]
10954 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html>"]
10955 pub struct DisplaySurfaceCreateInfoKHR {
10956     pub s_type: StructureType,
10957     pub p_next: *const c_void,
10958     pub flags: DisplaySurfaceCreateFlagsKHR,
10959     pub display_mode: DisplayModeKHR,
10960     pub plane_index: u32,
10961     pub plane_stack_index: u32,
10962     pub transform: SurfaceTransformFlagsKHR,
10963     pub global_alpha: f32,
10964     pub alpha_mode: DisplayPlaneAlphaFlagsKHR,
10965     pub image_extent: Extent2D,
10966 }
10967 impl ::std::default::Default for DisplaySurfaceCreateInfoKHR {
default() -> DisplaySurfaceCreateInfoKHR10968     fn default() -> DisplaySurfaceCreateInfoKHR {
10969         DisplaySurfaceCreateInfoKHR {
10970             s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR,
10971             p_next: ::std::ptr::null(),
10972             flags: DisplaySurfaceCreateFlagsKHR::default(),
10973             display_mode: DisplayModeKHR::default(),
10974             plane_index: u32::default(),
10975             plane_stack_index: u32::default(),
10976             transform: SurfaceTransformFlagsKHR::default(),
10977             global_alpha: f32::default(),
10978             alpha_mode: DisplayPlaneAlphaFlagsKHR::default(),
10979             image_extent: Extent2D::default(),
10980         }
10981     }
10982 }
10983 impl DisplaySurfaceCreateInfoKHR {
builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a>10984     pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
10985         DisplaySurfaceCreateInfoKHRBuilder {
10986             inner: DisplaySurfaceCreateInfoKHR::default(),
10987             marker: ::std::marker::PhantomData,
10988         }
10989     }
10990 }
10991 #[repr(transparent)]
10992 pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> {
10993     inner: DisplaySurfaceCreateInfoKHR,
10994     marker: ::std::marker::PhantomData<&'a ()>,
10995 }
10996 pub unsafe trait ExtendsDisplaySurfaceCreateInfoKHR {}
10997 impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> {
10998     type Target = DisplaySurfaceCreateInfoKHR;
deref(&self) -> &Self::Target10999     fn deref(&self) -> &Self::Target {
11000         &self.inner
11001     }
11002 }
11003 impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11004     fn deref_mut(&mut self) -> &mut Self::Target {
11005         &mut self.inner
11006     }
11007 }
11008 impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
flags( mut self, flags: DisplaySurfaceCreateFlagsKHR, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11009     pub fn flags(
11010         mut self,
11011         flags: DisplaySurfaceCreateFlagsKHR,
11012     ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11013         self.inner.flags = flags;
11014         self
11015     }
display_mode( mut self, display_mode: DisplayModeKHR, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11016     pub fn display_mode(
11017         mut self,
11018         display_mode: DisplayModeKHR,
11019     ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11020         self.inner.display_mode = display_mode;
11021         self
11022     }
plane_index(mut self, plane_index: u32) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11023     pub fn plane_index(mut self, plane_index: u32) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11024         self.inner.plane_index = plane_index;
11025         self
11026     }
plane_stack_index( mut self, plane_stack_index: u32, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11027     pub fn plane_stack_index(
11028         mut self,
11029         plane_stack_index: u32,
11030     ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11031         self.inner.plane_stack_index = plane_stack_index;
11032         self
11033     }
transform( mut self, transform: SurfaceTransformFlagsKHR, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11034     pub fn transform(
11035         mut self,
11036         transform: SurfaceTransformFlagsKHR,
11037     ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11038         self.inner.transform = transform;
11039         self
11040     }
global_alpha(mut self, global_alpha: f32) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11041     pub fn global_alpha(mut self, global_alpha: f32) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11042         self.inner.global_alpha = global_alpha;
11043         self
11044     }
alpha_mode( mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11045     pub fn alpha_mode(
11046         mut self,
11047         alpha_mode: DisplayPlaneAlphaFlagsKHR,
11048     ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11049         self.inner.alpha_mode = alpha_mode;
11050         self
11051     }
image_extent( mut self, image_extent: Extent2D, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11052     pub fn image_extent(
11053         mut self,
11054         image_extent: Extent2D,
11055     ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11056         self.inner.image_extent = image_extent;
11057         self
11058     }
11059     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11060     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11061     #[doc = r" valid extension structs can be pushed into the chain."]
11062     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11063     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplaySurfaceCreateInfoKHR>( mut self, next: &'a mut T, ) -> DisplaySurfaceCreateInfoKHRBuilder<'a>11064     pub fn push_next<T: ExtendsDisplaySurfaceCreateInfoKHR>(
11065         mut self,
11066         next: &'a mut T,
11067     ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
11068         unsafe {
11069             let next_ptr = next as *mut T as *mut BaseOutStructure;
11070             let last_next = ptr_chain_iter(next).last().unwrap();
11071             (*last_next).p_next = self.inner.p_next as _;
11072             self.inner.p_next = next_ptr as _;
11073         }
11074         self
11075     }
11076     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11077     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11078     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplaySurfaceCreateInfoKHR11079     pub fn build(self) -> DisplaySurfaceCreateInfoKHR {
11080         self.inner
11081     }
11082 }
11083 #[repr(C)]
11084 #[derive(Copy, Clone, Debug)]
11085 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPresentInfoKHR.html>"]
11086 pub struct DisplayPresentInfoKHR {
11087     pub s_type: StructureType,
11088     pub p_next: *const c_void,
11089     pub src_rect: Rect2D,
11090     pub dst_rect: Rect2D,
11091     pub persistent: Bool32,
11092 }
11093 impl ::std::default::Default for DisplayPresentInfoKHR {
default() -> DisplayPresentInfoKHR11094     fn default() -> DisplayPresentInfoKHR {
11095         DisplayPresentInfoKHR {
11096             s_type: StructureType::DISPLAY_PRESENT_INFO_KHR,
11097             p_next: ::std::ptr::null(),
11098             src_rect: Rect2D::default(),
11099             dst_rect: Rect2D::default(),
11100             persistent: Bool32::default(),
11101         }
11102     }
11103 }
11104 impl DisplayPresentInfoKHR {
builder<'a>() -> DisplayPresentInfoKHRBuilder<'a>11105     pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> {
11106         DisplayPresentInfoKHRBuilder {
11107             inner: DisplayPresentInfoKHR::default(),
11108             marker: ::std::marker::PhantomData,
11109         }
11110     }
11111 }
11112 #[repr(transparent)]
11113 pub struct DisplayPresentInfoKHRBuilder<'a> {
11114     inner: DisplayPresentInfoKHR,
11115     marker: ::std::marker::PhantomData<&'a ()>,
11116 }
11117 unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {}
11118 unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {}
11119 impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> {
11120     type Target = DisplayPresentInfoKHR;
deref(&self) -> &Self::Target11121     fn deref(&self) -> &Self::Target {
11122         &self.inner
11123     }
11124 }
11125 impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11126     fn deref_mut(&mut self) -> &mut Self::Target {
11127         &mut self.inner
11128     }
11129 }
11130 impl<'a> DisplayPresentInfoKHRBuilder<'a> {
src_rect(mut self, src_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a>11131     pub fn src_rect(mut self, src_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a> {
11132         self.inner.src_rect = src_rect;
11133         self
11134     }
dst_rect(mut self, dst_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a>11135     pub fn dst_rect(mut self, dst_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a> {
11136         self.inner.dst_rect = dst_rect;
11137         self
11138     }
persistent(mut self, persistent: bool) -> DisplayPresentInfoKHRBuilder<'a>11139     pub fn persistent(mut self, persistent: bool) -> DisplayPresentInfoKHRBuilder<'a> {
11140         self.inner.persistent = persistent.into();
11141         self
11142     }
11143     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11144     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11145     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPresentInfoKHR11146     pub fn build(self) -> DisplayPresentInfoKHR {
11147         self.inner
11148     }
11149 }
11150 #[repr(C)]
11151 #[derive(Copy, Clone, Default, Debug)]
11152 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilitiesKHR.html>"]
11153 pub struct SurfaceCapabilitiesKHR {
11154     pub min_image_count: u32,
11155     pub max_image_count: u32,
11156     pub current_extent: Extent2D,
11157     pub min_image_extent: Extent2D,
11158     pub max_image_extent: Extent2D,
11159     pub max_image_array_layers: u32,
11160     pub supported_transforms: SurfaceTransformFlagsKHR,
11161     pub current_transform: SurfaceTransformFlagsKHR,
11162     pub supported_composite_alpha: CompositeAlphaFlagsKHR,
11163     pub supported_usage_flags: ImageUsageFlags,
11164 }
11165 impl SurfaceCapabilitiesKHR {
builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a>11166     pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> {
11167         SurfaceCapabilitiesKHRBuilder {
11168             inner: SurfaceCapabilitiesKHR::default(),
11169             marker: ::std::marker::PhantomData,
11170         }
11171     }
11172 }
11173 #[repr(transparent)]
11174 pub struct SurfaceCapabilitiesKHRBuilder<'a> {
11175     inner: SurfaceCapabilitiesKHR,
11176     marker: ::std::marker::PhantomData<&'a ()>,
11177 }
11178 impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> {
11179     type Target = SurfaceCapabilitiesKHR;
deref(&self) -> &Self::Target11180     fn deref(&self) -> &Self::Target {
11181         &self.inner
11182     }
11183 }
11184 impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11185     fn deref_mut(&mut self) -> &mut Self::Target {
11186         &mut self.inner
11187     }
11188 }
11189 impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a>11190     pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a> {
11191         self.inner.min_image_count = min_image_count;
11192         self
11193     }
max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a>11194     pub fn max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a> {
11195         self.inner.max_image_count = max_image_count;
11196         self
11197     }
current_extent(mut self, current_extent: Extent2D) -> SurfaceCapabilitiesKHRBuilder<'a>11198     pub fn current_extent(mut self, current_extent: Extent2D) -> SurfaceCapabilitiesKHRBuilder<'a> {
11199         self.inner.current_extent = current_extent;
11200         self
11201     }
min_image_extent( mut self, min_image_extent: Extent2D, ) -> SurfaceCapabilitiesKHRBuilder<'a>11202     pub fn min_image_extent(
11203         mut self,
11204         min_image_extent: Extent2D,
11205     ) -> SurfaceCapabilitiesKHRBuilder<'a> {
11206         self.inner.min_image_extent = min_image_extent;
11207         self
11208     }
max_image_extent( mut self, max_image_extent: Extent2D, ) -> SurfaceCapabilitiesKHRBuilder<'a>11209     pub fn max_image_extent(
11210         mut self,
11211         max_image_extent: Extent2D,
11212     ) -> SurfaceCapabilitiesKHRBuilder<'a> {
11213         self.inner.max_image_extent = max_image_extent;
11214         self
11215     }
max_image_array_layers( mut self, max_image_array_layers: u32, ) -> SurfaceCapabilitiesKHRBuilder<'a>11216     pub fn max_image_array_layers(
11217         mut self,
11218         max_image_array_layers: u32,
11219     ) -> SurfaceCapabilitiesKHRBuilder<'a> {
11220         self.inner.max_image_array_layers = max_image_array_layers;
11221         self
11222     }
supported_transforms( mut self, supported_transforms: SurfaceTransformFlagsKHR, ) -> SurfaceCapabilitiesKHRBuilder<'a>11223     pub fn supported_transforms(
11224         mut self,
11225         supported_transforms: SurfaceTransformFlagsKHR,
11226     ) -> SurfaceCapabilitiesKHRBuilder<'a> {
11227         self.inner.supported_transforms = supported_transforms;
11228         self
11229     }
current_transform( mut self, current_transform: SurfaceTransformFlagsKHR, ) -> SurfaceCapabilitiesKHRBuilder<'a>11230     pub fn current_transform(
11231         mut self,
11232         current_transform: SurfaceTransformFlagsKHR,
11233     ) -> SurfaceCapabilitiesKHRBuilder<'a> {
11234         self.inner.current_transform = current_transform;
11235         self
11236     }
supported_composite_alpha( mut self, supported_composite_alpha: CompositeAlphaFlagsKHR, ) -> SurfaceCapabilitiesKHRBuilder<'a>11237     pub fn supported_composite_alpha(
11238         mut self,
11239         supported_composite_alpha: CompositeAlphaFlagsKHR,
11240     ) -> SurfaceCapabilitiesKHRBuilder<'a> {
11241         self.inner.supported_composite_alpha = supported_composite_alpha;
11242         self
11243     }
supported_usage_flags( mut self, supported_usage_flags: ImageUsageFlags, ) -> SurfaceCapabilitiesKHRBuilder<'a>11244     pub fn supported_usage_flags(
11245         mut self,
11246         supported_usage_flags: ImageUsageFlags,
11247     ) -> SurfaceCapabilitiesKHRBuilder<'a> {
11248         self.inner.supported_usage_flags = supported_usage_flags;
11249         self
11250     }
11251     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11252     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11253     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilitiesKHR11254     pub fn build(self) -> SurfaceCapabilitiesKHR {
11255         self.inner
11256     }
11257 }
11258 #[repr(C)]
11259 #[derive(Copy, Clone, Debug)]
11260 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateInfoKHR.html>"]
11261 pub struct AndroidSurfaceCreateInfoKHR {
11262     pub s_type: StructureType,
11263     pub p_next: *const c_void,
11264     pub flags: AndroidSurfaceCreateFlagsKHR,
11265     pub window: *mut ANativeWindow,
11266 }
11267 impl ::std::default::Default for AndroidSurfaceCreateInfoKHR {
default() -> AndroidSurfaceCreateInfoKHR11268     fn default() -> AndroidSurfaceCreateInfoKHR {
11269         AndroidSurfaceCreateInfoKHR {
11270             s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR,
11271             p_next: ::std::ptr::null(),
11272             flags: AndroidSurfaceCreateFlagsKHR::default(),
11273             window: ::std::ptr::null_mut(),
11274         }
11275     }
11276 }
11277 impl AndroidSurfaceCreateInfoKHR {
builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a>11278     pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
11279         AndroidSurfaceCreateInfoKHRBuilder {
11280             inner: AndroidSurfaceCreateInfoKHR::default(),
11281             marker: ::std::marker::PhantomData,
11282         }
11283     }
11284 }
11285 #[repr(transparent)]
11286 pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> {
11287     inner: AndroidSurfaceCreateInfoKHR,
11288     marker: ::std::marker::PhantomData<&'a ()>,
11289 }
11290 pub unsafe trait ExtendsAndroidSurfaceCreateInfoKHR {}
11291 impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> {
11292     type Target = AndroidSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11293     fn deref(&self) -> &Self::Target {
11294         &self.inner
11295     }
11296 }
11297 impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11298     fn deref_mut(&mut self) -> &mut Self::Target {
11299         &mut self.inner
11300     }
11301 }
11302 impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
flags( mut self, flags: AndroidSurfaceCreateFlagsKHR, ) -> AndroidSurfaceCreateInfoKHRBuilder<'a>11303     pub fn flags(
11304         mut self,
11305         flags: AndroidSurfaceCreateFlagsKHR,
11306     ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
11307         self.inner.flags = flags;
11308         self
11309     }
window(mut self, window: *mut ANativeWindow) -> AndroidSurfaceCreateInfoKHRBuilder<'a>11310     pub fn window(mut self, window: *mut ANativeWindow) -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
11311         self.inner.window = window;
11312         self
11313     }
11314     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11315     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11316     #[doc = r" valid extension structs can be pushed into the chain."]
11317     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11318     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAndroidSurfaceCreateInfoKHR>( mut self, next: &'a mut T, ) -> AndroidSurfaceCreateInfoKHRBuilder<'a>11319     pub fn push_next<T: ExtendsAndroidSurfaceCreateInfoKHR>(
11320         mut self,
11321         next: &'a mut T,
11322     ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
11323         unsafe {
11324             let next_ptr = next as *mut T as *mut BaseOutStructure;
11325             let last_next = ptr_chain_iter(next).last().unwrap();
11326             (*last_next).p_next = self.inner.p_next as _;
11327             self.inner.p_next = next_ptr as _;
11328         }
11329         self
11330     }
11331     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11332     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11333     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidSurfaceCreateInfoKHR11334     pub fn build(self) -> AndroidSurfaceCreateInfoKHR {
11335         self.inner
11336     }
11337 }
11338 #[repr(C)]
11339 #[derive(Copy, Clone, Debug)]
11340 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateInfoNN.html>"]
11341 pub struct ViSurfaceCreateInfoNN {
11342     pub s_type: StructureType,
11343     pub p_next: *const c_void,
11344     pub flags: ViSurfaceCreateFlagsNN,
11345     pub window: *mut c_void,
11346 }
11347 impl ::std::default::Default for ViSurfaceCreateInfoNN {
default() -> ViSurfaceCreateInfoNN11348     fn default() -> ViSurfaceCreateInfoNN {
11349         ViSurfaceCreateInfoNN {
11350             s_type: StructureType::VI_SURFACE_CREATE_INFO_NN,
11351             p_next: ::std::ptr::null(),
11352             flags: ViSurfaceCreateFlagsNN::default(),
11353             window: ::std::ptr::null_mut(),
11354         }
11355     }
11356 }
11357 impl ViSurfaceCreateInfoNN {
builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a>11358     pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> {
11359         ViSurfaceCreateInfoNNBuilder {
11360             inner: ViSurfaceCreateInfoNN::default(),
11361             marker: ::std::marker::PhantomData,
11362         }
11363     }
11364 }
11365 #[repr(transparent)]
11366 pub struct ViSurfaceCreateInfoNNBuilder<'a> {
11367     inner: ViSurfaceCreateInfoNN,
11368     marker: ::std::marker::PhantomData<&'a ()>,
11369 }
11370 pub unsafe trait ExtendsViSurfaceCreateInfoNN {}
11371 impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> {
11372     type Target = ViSurfaceCreateInfoNN;
deref(&self) -> &Self::Target11373     fn deref(&self) -> &Self::Target {
11374         &self.inner
11375     }
11376 }
11377 impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11378     fn deref_mut(&mut self) -> &mut Self::Target {
11379         &mut self.inner
11380     }
11381 }
11382 impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
flags(mut self, flags: ViSurfaceCreateFlagsNN) -> ViSurfaceCreateInfoNNBuilder<'a>11383     pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> ViSurfaceCreateInfoNNBuilder<'a> {
11384         self.inner.flags = flags;
11385         self
11386     }
window(mut self, window: *mut c_void) -> ViSurfaceCreateInfoNNBuilder<'a>11387     pub fn window(mut self, window: *mut c_void) -> ViSurfaceCreateInfoNNBuilder<'a> {
11388         self.inner.window = window;
11389         self
11390     }
11391     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11392     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11393     #[doc = r" valid extension structs can be pushed into the chain."]
11394     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11395     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsViSurfaceCreateInfoNN>( mut self, next: &'a mut T, ) -> ViSurfaceCreateInfoNNBuilder<'a>11396     pub fn push_next<T: ExtendsViSurfaceCreateInfoNN>(
11397         mut self,
11398         next: &'a mut T,
11399     ) -> ViSurfaceCreateInfoNNBuilder<'a> {
11400         unsafe {
11401             let next_ptr = next as *mut T as *mut BaseOutStructure;
11402             let last_next = ptr_chain_iter(next).last().unwrap();
11403             (*last_next).p_next = self.inner.p_next as _;
11404             self.inner.p_next = next_ptr as _;
11405         }
11406         self
11407     }
11408     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11409     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11410     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ViSurfaceCreateInfoNN11411     pub fn build(self) -> ViSurfaceCreateInfoNN {
11412         self.inner
11413     }
11414 }
11415 #[repr(C)]
11416 #[derive(Copy, Clone, Debug)]
11417 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateInfoKHR.html>"]
11418 pub struct WaylandSurfaceCreateInfoKHR {
11419     pub s_type: StructureType,
11420     pub p_next: *const c_void,
11421     pub flags: WaylandSurfaceCreateFlagsKHR,
11422     pub display: *mut wl_display,
11423     pub surface: *mut wl_surface,
11424 }
11425 impl ::std::default::Default for WaylandSurfaceCreateInfoKHR {
default() -> WaylandSurfaceCreateInfoKHR11426     fn default() -> WaylandSurfaceCreateInfoKHR {
11427         WaylandSurfaceCreateInfoKHR {
11428             s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR,
11429             p_next: ::std::ptr::null(),
11430             flags: WaylandSurfaceCreateFlagsKHR::default(),
11431             display: ::std::ptr::null_mut(),
11432             surface: ::std::ptr::null_mut(),
11433         }
11434     }
11435 }
11436 impl WaylandSurfaceCreateInfoKHR {
builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a>11437     pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
11438         WaylandSurfaceCreateInfoKHRBuilder {
11439             inner: WaylandSurfaceCreateInfoKHR::default(),
11440             marker: ::std::marker::PhantomData,
11441         }
11442     }
11443 }
11444 #[repr(transparent)]
11445 pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> {
11446     inner: WaylandSurfaceCreateInfoKHR,
11447     marker: ::std::marker::PhantomData<&'a ()>,
11448 }
11449 pub unsafe trait ExtendsWaylandSurfaceCreateInfoKHR {}
11450 impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> {
11451     type Target = WaylandSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11452     fn deref(&self) -> &Self::Target {
11453         &self.inner
11454     }
11455 }
11456 impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11457     fn deref_mut(&mut self) -> &mut Self::Target {
11458         &mut self.inner
11459     }
11460 }
11461 impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
flags( mut self, flags: WaylandSurfaceCreateFlagsKHR, ) -> WaylandSurfaceCreateInfoKHRBuilder<'a>11462     pub fn flags(
11463         mut self,
11464         flags: WaylandSurfaceCreateFlagsKHR,
11465     ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
11466         self.inner.flags = flags;
11467         self
11468     }
display(mut self, display: *mut wl_display) -> WaylandSurfaceCreateInfoKHRBuilder<'a>11469     pub fn display(mut self, display: *mut wl_display) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
11470         self.inner.display = display;
11471         self
11472     }
surface(mut self, surface: *mut wl_surface) -> WaylandSurfaceCreateInfoKHRBuilder<'a>11473     pub fn surface(mut self, surface: *mut wl_surface) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
11474         self.inner.surface = surface;
11475         self
11476     }
11477     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11478     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11479     #[doc = r" valid extension structs can be pushed into the chain."]
11480     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11481     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsWaylandSurfaceCreateInfoKHR>( mut self, next: &'a mut T, ) -> WaylandSurfaceCreateInfoKHRBuilder<'a>11482     pub fn push_next<T: ExtendsWaylandSurfaceCreateInfoKHR>(
11483         mut self,
11484         next: &'a mut T,
11485     ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
11486         unsafe {
11487             let next_ptr = next as *mut T as *mut BaseOutStructure;
11488             let last_next = ptr_chain_iter(next).last().unwrap();
11489             (*last_next).p_next = self.inner.p_next as _;
11490             self.inner.p_next = next_ptr as _;
11491         }
11492         self
11493     }
11494     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11495     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11496     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WaylandSurfaceCreateInfoKHR11497     pub fn build(self) -> WaylandSurfaceCreateInfoKHR {
11498         self.inner
11499     }
11500 }
11501 #[repr(C)]
11502 #[derive(Copy, Clone, Debug)]
11503 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html>"]
11504 pub struct Win32SurfaceCreateInfoKHR {
11505     pub s_type: StructureType,
11506     pub p_next: *const c_void,
11507     pub flags: Win32SurfaceCreateFlagsKHR,
11508     pub hinstance: HINSTANCE,
11509     pub hwnd: HWND,
11510 }
11511 impl ::std::default::Default for Win32SurfaceCreateInfoKHR {
default() -> Win32SurfaceCreateInfoKHR11512     fn default() -> Win32SurfaceCreateInfoKHR {
11513         Win32SurfaceCreateInfoKHR {
11514             s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR,
11515             p_next: ::std::ptr::null(),
11516             flags: Win32SurfaceCreateFlagsKHR::default(),
11517             hinstance: unsafe { ::std::mem::zeroed() },
11518             hwnd: unsafe { ::std::mem::zeroed() },
11519         }
11520     }
11521 }
11522 impl Win32SurfaceCreateInfoKHR {
builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a>11523     pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
11524         Win32SurfaceCreateInfoKHRBuilder {
11525             inner: Win32SurfaceCreateInfoKHR::default(),
11526             marker: ::std::marker::PhantomData,
11527         }
11528     }
11529 }
11530 #[repr(transparent)]
11531 pub struct Win32SurfaceCreateInfoKHRBuilder<'a> {
11532     inner: Win32SurfaceCreateInfoKHR,
11533     marker: ::std::marker::PhantomData<&'a ()>,
11534 }
11535 pub unsafe trait ExtendsWin32SurfaceCreateInfoKHR {}
11536 impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
11537     type Target = Win32SurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11538     fn deref(&self) -> &Self::Target {
11539         &self.inner
11540     }
11541 }
11542 impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11543     fn deref_mut(&mut self) -> &mut Self::Target {
11544         &mut self.inner
11545     }
11546 }
11547 impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
flags( mut self, flags: Win32SurfaceCreateFlagsKHR, ) -> Win32SurfaceCreateInfoKHRBuilder<'a>11548     pub fn flags(
11549         mut self,
11550         flags: Win32SurfaceCreateFlagsKHR,
11551     ) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
11552         self.inner.flags = flags;
11553         self
11554     }
hinstance(mut self, hinstance: HINSTANCE) -> Win32SurfaceCreateInfoKHRBuilder<'a>11555     pub fn hinstance(mut self, hinstance: HINSTANCE) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
11556         self.inner.hinstance = hinstance;
11557         self
11558     }
hwnd(mut self, hwnd: HWND) -> Win32SurfaceCreateInfoKHRBuilder<'a>11559     pub fn hwnd(mut self, hwnd: HWND) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
11560         self.inner.hwnd = hwnd;
11561         self
11562     }
11563     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11564     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11565     #[doc = r" valid extension structs can be pushed into the chain."]
11566     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11567     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsWin32SurfaceCreateInfoKHR>( mut self, next: &'a mut T, ) -> Win32SurfaceCreateInfoKHRBuilder<'a>11568     pub fn push_next<T: ExtendsWin32SurfaceCreateInfoKHR>(
11569         mut self,
11570         next: &'a mut T,
11571     ) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
11572         unsafe {
11573             let next_ptr = next as *mut T as *mut BaseOutStructure;
11574             let last_next = ptr_chain_iter(next).last().unwrap();
11575             (*last_next).p_next = self.inner.p_next as _;
11576             self.inner.p_next = next_ptr as _;
11577         }
11578         self
11579     }
11580     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11581     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11582     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Win32SurfaceCreateInfoKHR11583     pub fn build(self) -> Win32SurfaceCreateInfoKHR {
11584         self.inner
11585     }
11586 }
11587 #[repr(C)]
11588 #[derive(Copy, Clone, Debug)]
11589 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateInfoKHR.html>"]
11590 pub struct XlibSurfaceCreateInfoKHR {
11591     pub s_type: StructureType,
11592     pub p_next: *const c_void,
11593     pub flags: XlibSurfaceCreateFlagsKHR,
11594     pub dpy: *mut Display,
11595     pub window: Window,
11596 }
11597 impl ::std::default::Default for XlibSurfaceCreateInfoKHR {
default() -> XlibSurfaceCreateInfoKHR11598     fn default() -> XlibSurfaceCreateInfoKHR {
11599         XlibSurfaceCreateInfoKHR {
11600             s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR,
11601             p_next: ::std::ptr::null(),
11602             flags: XlibSurfaceCreateFlagsKHR::default(),
11603             dpy: ::std::ptr::null_mut(),
11604             window: Window::default(),
11605         }
11606     }
11607 }
11608 impl XlibSurfaceCreateInfoKHR {
builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a>11609     pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> {
11610         XlibSurfaceCreateInfoKHRBuilder {
11611             inner: XlibSurfaceCreateInfoKHR::default(),
11612             marker: ::std::marker::PhantomData,
11613         }
11614     }
11615 }
11616 #[repr(transparent)]
11617 pub struct XlibSurfaceCreateInfoKHRBuilder<'a> {
11618     inner: XlibSurfaceCreateInfoKHR,
11619     marker: ::std::marker::PhantomData<&'a ()>,
11620 }
11621 pub unsafe trait ExtendsXlibSurfaceCreateInfoKHR {}
11622 impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> {
11623     type Target = XlibSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11624     fn deref(&self) -> &Self::Target {
11625         &self.inner
11626     }
11627 }
11628 impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11629     fn deref_mut(&mut self) -> &mut Self::Target {
11630         &mut self.inner
11631     }
11632 }
11633 impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
flags( mut self, flags: XlibSurfaceCreateFlagsKHR, ) -> XlibSurfaceCreateInfoKHRBuilder<'a>11634     pub fn flags(
11635         mut self,
11636         flags: XlibSurfaceCreateFlagsKHR,
11637     ) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
11638         self.inner.flags = flags;
11639         self
11640     }
dpy(mut self, dpy: *mut Display) -> XlibSurfaceCreateInfoKHRBuilder<'a>11641     pub fn dpy(mut self, dpy: *mut Display) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
11642         self.inner.dpy = dpy;
11643         self
11644     }
window(mut self, window: Window) -> XlibSurfaceCreateInfoKHRBuilder<'a>11645     pub fn window(mut self, window: Window) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
11646         self.inner.window = window;
11647         self
11648     }
11649     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11650     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11651     #[doc = r" valid extension structs can be pushed into the chain."]
11652     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11653     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsXlibSurfaceCreateInfoKHR>( mut self, next: &'a mut T, ) -> XlibSurfaceCreateInfoKHRBuilder<'a>11654     pub fn push_next<T: ExtendsXlibSurfaceCreateInfoKHR>(
11655         mut self,
11656         next: &'a mut T,
11657     ) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
11658         unsafe {
11659             let next_ptr = next as *mut T as *mut BaseOutStructure;
11660             let last_next = ptr_chain_iter(next).last().unwrap();
11661             (*last_next).p_next = self.inner.p_next as _;
11662             self.inner.p_next = next_ptr as _;
11663         }
11664         self
11665     }
11666     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11667     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11668     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> XlibSurfaceCreateInfoKHR11669     pub fn build(self) -> XlibSurfaceCreateInfoKHR {
11670         self.inner
11671     }
11672 }
11673 #[repr(C)]
11674 #[derive(Copy, Clone, Debug)]
11675 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateInfoKHR.html>"]
11676 pub struct XcbSurfaceCreateInfoKHR {
11677     pub s_type: StructureType,
11678     pub p_next: *const c_void,
11679     pub flags: XcbSurfaceCreateFlagsKHR,
11680     pub connection: *mut xcb_connection_t,
11681     pub window: xcb_window_t,
11682 }
11683 impl ::std::default::Default for XcbSurfaceCreateInfoKHR {
default() -> XcbSurfaceCreateInfoKHR11684     fn default() -> XcbSurfaceCreateInfoKHR {
11685         XcbSurfaceCreateInfoKHR {
11686             s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR,
11687             p_next: ::std::ptr::null(),
11688             flags: XcbSurfaceCreateFlagsKHR::default(),
11689             connection: ::std::ptr::null_mut(),
11690             window: xcb_window_t::default(),
11691         }
11692     }
11693 }
11694 impl XcbSurfaceCreateInfoKHR {
builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a>11695     pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
11696         XcbSurfaceCreateInfoKHRBuilder {
11697             inner: XcbSurfaceCreateInfoKHR::default(),
11698             marker: ::std::marker::PhantomData,
11699         }
11700     }
11701 }
11702 #[repr(transparent)]
11703 pub struct XcbSurfaceCreateInfoKHRBuilder<'a> {
11704     inner: XcbSurfaceCreateInfoKHR,
11705     marker: ::std::marker::PhantomData<&'a ()>,
11706 }
11707 pub unsafe trait ExtendsXcbSurfaceCreateInfoKHR {}
11708 impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
11709     type Target = XcbSurfaceCreateInfoKHR;
deref(&self) -> &Self::Target11710     fn deref(&self) -> &Self::Target {
11711         &self.inner
11712     }
11713 }
11714 impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11715     fn deref_mut(&mut self) -> &mut Self::Target {
11716         &mut self.inner
11717     }
11718 }
11719 impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> XcbSurfaceCreateInfoKHRBuilder<'a>11720     pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
11721         self.inner.flags = flags;
11722         self
11723     }
connection( mut self, connection: *mut xcb_connection_t, ) -> XcbSurfaceCreateInfoKHRBuilder<'a>11724     pub fn connection(
11725         mut self,
11726         connection: *mut xcb_connection_t,
11727     ) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
11728         self.inner.connection = connection;
11729         self
11730     }
window(mut self, window: xcb_window_t) -> XcbSurfaceCreateInfoKHRBuilder<'a>11731     pub fn window(mut self, window: xcb_window_t) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
11732         self.inner.window = window;
11733         self
11734     }
11735     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11736     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11737     #[doc = r" valid extension structs can be pushed into the chain."]
11738     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11739     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsXcbSurfaceCreateInfoKHR>( mut self, next: &'a mut T, ) -> XcbSurfaceCreateInfoKHRBuilder<'a>11740     pub fn push_next<T: ExtendsXcbSurfaceCreateInfoKHR>(
11741         mut self,
11742         next: &'a mut T,
11743     ) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
11744         unsafe {
11745             let next_ptr = next as *mut T as *mut BaseOutStructure;
11746             let last_next = ptr_chain_iter(next).last().unwrap();
11747             (*last_next).p_next = self.inner.p_next as _;
11748             self.inner.p_next = next_ptr as _;
11749         }
11750         self
11751     }
11752     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11753     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11754     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> XcbSurfaceCreateInfoKHR11755     pub fn build(self) -> XcbSurfaceCreateInfoKHR {
11756         self.inner
11757     }
11758 }
11759 #[repr(C)]
11760 #[derive(Copy, Clone, Debug)]
11761 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDirectFBSurfaceCreateInfoEXT.html>"]
11762 pub struct DirectFBSurfaceCreateInfoEXT {
11763     pub s_type: StructureType,
11764     pub p_next: *const c_void,
11765     pub flags: DirectFBSurfaceCreateFlagsEXT,
11766     pub dfb: *mut IDirectFB,
11767     pub surface: *mut IDirectFBSurface,
11768 }
11769 impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT {
default() -> DirectFBSurfaceCreateInfoEXT11770     fn default() -> DirectFBSurfaceCreateInfoEXT {
11771         DirectFBSurfaceCreateInfoEXT {
11772             s_type: StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT,
11773             p_next: ::std::ptr::null(),
11774             flags: DirectFBSurfaceCreateFlagsEXT::default(),
11775             dfb: ::std::ptr::null_mut(),
11776             surface: ::std::ptr::null_mut(),
11777         }
11778     }
11779 }
11780 impl DirectFBSurfaceCreateInfoEXT {
builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a>11781     pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11782         DirectFBSurfaceCreateInfoEXTBuilder {
11783             inner: DirectFBSurfaceCreateInfoEXT::default(),
11784             marker: ::std::marker::PhantomData,
11785         }
11786     }
11787 }
11788 #[repr(transparent)]
11789 pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11790     inner: DirectFBSurfaceCreateInfoEXT,
11791     marker: ::std::marker::PhantomData<&'a ()>,
11792 }
11793 pub unsafe trait ExtendsDirectFBSurfaceCreateInfoEXT {}
11794 impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11795     type Target = DirectFBSurfaceCreateInfoEXT;
deref(&self) -> &Self::Target11796     fn deref(&self) -> &Self::Target {
11797         &self.inner
11798     }
11799 }
11800 impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11801     fn deref_mut(&mut self) -> &mut Self::Target {
11802         &mut self.inner
11803     }
11804 }
11805 impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
flags( mut self, flags: DirectFBSurfaceCreateFlagsEXT, ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a>11806     pub fn flags(
11807         mut self,
11808         flags: DirectFBSurfaceCreateFlagsEXT,
11809     ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11810         self.inner.flags = flags;
11811         self
11812     }
dfb(mut self, dfb: *mut IDirectFB) -> DirectFBSurfaceCreateInfoEXTBuilder<'a>11813     pub fn dfb(mut self, dfb: *mut IDirectFB) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11814         self.inner.dfb = dfb;
11815         self
11816     }
surface( mut self, surface: *mut IDirectFBSurface, ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a>11817     pub fn surface(
11818         mut self,
11819         surface: *mut IDirectFBSurface,
11820     ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11821         self.inner.surface = surface;
11822         self
11823     }
11824     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11825     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11826     #[doc = r" valid extension structs can be pushed into the chain."]
11827     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11828     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDirectFBSurfaceCreateInfoEXT>( mut self, next: &'a mut T, ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a>11829     pub fn push_next<T: ExtendsDirectFBSurfaceCreateInfoEXT>(
11830         mut self,
11831         next: &'a mut T,
11832     ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
11833         unsafe {
11834             let next_ptr = next as *mut T as *mut BaseOutStructure;
11835             let last_next = ptr_chain_iter(next).last().unwrap();
11836             (*last_next).p_next = self.inner.p_next as _;
11837             self.inner.p_next = next_ptr as _;
11838         }
11839         self
11840     }
11841     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11842     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11843     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DirectFBSurfaceCreateInfoEXT11844     pub fn build(self) -> DirectFBSurfaceCreateInfoEXT {
11845         self.inner
11846     }
11847 }
11848 #[repr(C)]
11849 #[derive(Copy, Clone, Debug)]
11850 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>"]
11851 pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
11852     pub s_type: StructureType,
11853     pub p_next: *const c_void,
11854     pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
11855     pub image_pipe_handle: zx_handle_t,
11856 }
11857 impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA {
default() -> ImagePipeSurfaceCreateInfoFUCHSIA11858     fn default() -> ImagePipeSurfaceCreateInfoFUCHSIA {
11859         ImagePipeSurfaceCreateInfoFUCHSIA {
11860             s_type: StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
11861             p_next: ::std::ptr::null(),
11862             flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(),
11863             image_pipe_handle: zx_handle_t::default(),
11864         }
11865     }
11866 }
11867 impl ImagePipeSurfaceCreateInfoFUCHSIA {
builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a>11868     pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11869         ImagePipeSurfaceCreateInfoFUCHSIABuilder {
11870             inner: ImagePipeSurfaceCreateInfoFUCHSIA::default(),
11871             marker: ::std::marker::PhantomData,
11872         }
11873     }
11874 }
11875 #[repr(transparent)]
11876 pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11877     inner: ImagePipeSurfaceCreateInfoFUCHSIA,
11878     marker: ::std::marker::PhantomData<&'a ()>,
11879 }
11880 pub unsafe trait ExtendsImagePipeSurfaceCreateInfoFUCHSIA {}
11881 impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11882     type Target = ImagePipeSurfaceCreateInfoFUCHSIA;
deref(&self) -> &Self::Target11883     fn deref(&self) -> &Self::Target {
11884         &self.inner
11885     }
11886 }
11887 impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11888     fn deref_mut(&mut self) -> &mut Self::Target {
11889         &mut self.inner
11890     }
11891 }
11892 impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
flags( mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA, ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a>11893     pub fn flags(
11894         mut self,
11895         flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
11896     ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11897         self.inner.flags = flags;
11898         self
11899     }
image_pipe_handle( mut self, image_pipe_handle: zx_handle_t, ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a>11900     pub fn image_pipe_handle(
11901         mut self,
11902         image_pipe_handle: zx_handle_t,
11903     ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11904         self.inner.image_pipe_handle = image_pipe_handle;
11905         self
11906     }
11907     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11908     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11909     #[doc = r" valid extension structs can be pushed into the chain."]
11910     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11911     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImagePipeSurfaceCreateInfoFUCHSIA>( mut self, next: &'a mut T, ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a>11912     pub fn push_next<T: ExtendsImagePipeSurfaceCreateInfoFUCHSIA>(
11913         mut self,
11914         next: &'a mut T,
11915     ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
11916         unsafe {
11917             let next_ptr = next as *mut T as *mut BaseOutStructure;
11918             let last_next = ptr_chain_iter(next).last().unwrap();
11919             (*last_next).p_next = self.inner.p_next as _;
11920             self.inner.p_next = next_ptr as _;
11921         }
11922         self
11923     }
11924     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
11925     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
11926     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA11927     pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA {
11928         self.inner
11929     }
11930 }
11931 #[repr(C)]
11932 #[derive(Copy, Clone, Debug)]
11933 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>"]
11934 pub struct StreamDescriptorSurfaceCreateInfoGGP {
11935     pub s_type: StructureType,
11936     pub p_next: *const c_void,
11937     pub flags: StreamDescriptorSurfaceCreateFlagsGGP,
11938     pub stream_descriptor: GgpStreamDescriptor,
11939 }
11940 impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP {
default() -> StreamDescriptorSurfaceCreateInfoGGP11941     fn default() -> StreamDescriptorSurfaceCreateInfoGGP {
11942         StreamDescriptorSurfaceCreateInfoGGP {
11943             s_type: StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
11944             p_next: ::std::ptr::null(),
11945             flags: StreamDescriptorSurfaceCreateFlagsGGP::default(),
11946             stream_descriptor: GgpStreamDescriptor::default(),
11947         }
11948     }
11949 }
11950 impl StreamDescriptorSurfaceCreateInfoGGP {
builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a>11951     pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
11952         StreamDescriptorSurfaceCreateInfoGGPBuilder {
11953             inner: StreamDescriptorSurfaceCreateInfoGGP::default(),
11954             marker: ::std::marker::PhantomData,
11955         }
11956     }
11957 }
11958 #[repr(transparent)]
11959 pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
11960     inner: StreamDescriptorSurfaceCreateInfoGGP,
11961     marker: ::std::marker::PhantomData<&'a ()>,
11962 }
11963 pub unsafe trait ExtendsStreamDescriptorSurfaceCreateInfoGGP {}
11964 impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
11965     type Target = StreamDescriptorSurfaceCreateInfoGGP;
deref(&self) -> &Self::Target11966     fn deref(&self) -> &Self::Target {
11967         &self.inner
11968     }
11969 }
11970 impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target11971     fn deref_mut(&mut self) -> &mut Self::Target {
11972         &mut self.inner
11973     }
11974 }
11975 impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
flags( mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP, ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a>11976     pub fn flags(
11977         mut self,
11978         flags: StreamDescriptorSurfaceCreateFlagsGGP,
11979     ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
11980         self.inner.flags = flags;
11981         self
11982     }
stream_descriptor( mut self, stream_descriptor: GgpStreamDescriptor, ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a>11983     pub fn stream_descriptor(
11984         mut self,
11985         stream_descriptor: GgpStreamDescriptor,
11986     ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
11987         self.inner.stream_descriptor = stream_descriptor;
11988         self
11989     }
11990     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
11991     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
11992     #[doc = r" valid extension structs can be pushed into the chain."]
11993     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
11994     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsStreamDescriptorSurfaceCreateInfoGGP>( mut self, next: &'a mut T, ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a>11995     pub fn push_next<T: ExtendsStreamDescriptorSurfaceCreateInfoGGP>(
11996         mut self,
11997         next: &'a mut T,
11998     ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
11999         unsafe {
12000             let next_ptr = next as *mut T as *mut BaseOutStructure;
12001             let last_next = ptr_chain_iter(next).last().unwrap();
12002             (*last_next).p_next = self.inner.p_next as _;
12003             self.inner.p_next = next_ptr as _;
12004         }
12005         self
12006     }
12007     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12008     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12009     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> StreamDescriptorSurfaceCreateInfoGGP12010     pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP {
12011         self.inner
12012     }
12013 }
12014 #[repr(C)]
12015 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
12016 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFormatKHR.html>"]
12017 pub struct SurfaceFormatKHR {
12018     pub format: Format,
12019     pub color_space: ColorSpaceKHR,
12020 }
12021 impl SurfaceFormatKHR {
builder<'a>() -> SurfaceFormatKHRBuilder<'a>12022     pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> {
12023         SurfaceFormatKHRBuilder {
12024             inner: SurfaceFormatKHR::default(),
12025             marker: ::std::marker::PhantomData,
12026         }
12027     }
12028 }
12029 #[repr(transparent)]
12030 pub struct SurfaceFormatKHRBuilder<'a> {
12031     inner: SurfaceFormatKHR,
12032     marker: ::std::marker::PhantomData<&'a ()>,
12033 }
12034 impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> {
12035     type Target = SurfaceFormatKHR;
deref(&self) -> &Self::Target12036     fn deref(&self) -> &Self::Target {
12037         &self.inner
12038     }
12039 }
12040 impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12041     fn deref_mut(&mut self) -> &mut Self::Target {
12042         &mut self.inner
12043     }
12044 }
12045 impl<'a> SurfaceFormatKHRBuilder<'a> {
format(mut self, format: Format) -> SurfaceFormatKHRBuilder<'a>12046     pub fn format(mut self, format: Format) -> SurfaceFormatKHRBuilder<'a> {
12047         self.inner.format = format;
12048         self
12049     }
color_space(mut self, color_space: ColorSpaceKHR) -> SurfaceFormatKHRBuilder<'a>12050     pub fn color_space(mut self, color_space: ColorSpaceKHR) -> SurfaceFormatKHRBuilder<'a> {
12051         self.inner.color_space = color_space;
12052         self
12053     }
12054     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12055     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12056     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFormatKHR12057     pub fn build(self) -> SurfaceFormatKHR {
12058         self.inner
12059     }
12060 }
12061 #[repr(C)]
12062 #[derive(Copy, Clone, Debug)]
12063 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateInfoKHR.html>"]
12064 pub struct SwapchainCreateInfoKHR {
12065     pub s_type: StructureType,
12066     pub p_next: *const c_void,
12067     pub flags: SwapchainCreateFlagsKHR,
12068     pub surface: SurfaceKHR,
12069     pub min_image_count: u32,
12070     pub image_format: Format,
12071     pub image_color_space: ColorSpaceKHR,
12072     pub image_extent: Extent2D,
12073     pub image_array_layers: u32,
12074     pub image_usage: ImageUsageFlags,
12075     pub image_sharing_mode: SharingMode,
12076     pub queue_family_index_count: u32,
12077     pub p_queue_family_indices: *const u32,
12078     pub pre_transform: SurfaceTransformFlagsKHR,
12079     pub composite_alpha: CompositeAlphaFlagsKHR,
12080     pub present_mode: PresentModeKHR,
12081     pub clipped: Bool32,
12082     pub old_swapchain: SwapchainKHR,
12083 }
12084 impl ::std::default::Default for SwapchainCreateInfoKHR {
default() -> SwapchainCreateInfoKHR12085     fn default() -> SwapchainCreateInfoKHR {
12086         SwapchainCreateInfoKHR {
12087             s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR,
12088             p_next: ::std::ptr::null(),
12089             flags: SwapchainCreateFlagsKHR::default(),
12090             surface: SurfaceKHR::default(),
12091             min_image_count: u32::default(),
12092             image_format: Format::default(),
12093             image_color_space: ColorSpaceKHR::default(),
12094             image_extent: Extent2D::default(),
12095             image_array_layers: u32::default(),
12096             image_usage: ImageUsageFlags::default(),
12097             image_sharing_mode: SharingMode::default(),
12098             queue_family_index_count: u32::default(),
12099             p_queue_family_indices: ::std::ptr::null(),
12100             pre_transform: SurfaceTransformFlagsKHR::default(),
12101             composite_alpha: CompositeAlphaFlagsKHR::default(),
12102             present_mode: PresentModeKHR::default(),
12103             clipped: Bool32::default(),
12104             old_swapchain: SwapchainKHR::default(),
12105         }
12106     }
12107 }
12108 impl SwapchainCreateInfoKHR {
builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a>12109     pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> {
12110         SwapchainCreateInfoKHRBuilder {
12111             inner: SwapchainCreateInfoKHR::default(),
12112             marker: ::std::marker::PhantomData,
12113         }
12114     }
12115 }
12116 #[repr(transparent)]
12117 pub struct SwapchainCreateInfoKHRBuilder<'a> {
12118     inner: SwapchainCreateInfoKHR,
12119     marker: ::std::marker::PhantomData<&'a ()>,
12120 }
12121 pub unsafe trait ExtendsSwapchainCreateInfoKHR {}
12122 impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> {
12123     type Target = SwapchainCreateInfoKHR;
deref(&self) -> &Self::Target12124     fn deref(&self) -> &Self::Target {
12125         &self.inner
12126     }
12127 }
12128 impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12129     fn deref_mut(&mut self) -> &mut Self::Target {
12130         &mut self.inner
12131     }
12132 }
12133 impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
flags(mut self, flags: SwapchainCreateFlagsKHR) -> SwapchainCreateInfoKHRBuilder<'a>12134     pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> SwapchainCreateInfoKHRBuilder<'a> {
12135         self.inner.flags = flags;
12136         self
12137     }
surface(mut self, surface: SurfaceKHR) -> SwapchainCreateInfoKHRBuilder<'a>12138     pub fn surface(mut self, surface: SurfaceKHR) -> SwapchainCreateInfoKHRBuilder<'a> {
12139         self.inner.surface = surface;
12140         self
12141     }
min_image_count(mut self, min_image_count: u32) -> SwapchainCreateInfoKHRBuilder<'a>12142     pub fn min_image_count(mut self, min_image_count: u32) -> SwapchainCreateInfoKHRBuilder<'a> {
12143         self.inner.min_image_count = min_image_count;
12144         self
12145     }
image_format(mut self, image_format: Format) -> SwapchainCreateInfoKHRBuilder<'a>12146     pub fn image_format(mut self, image_format: Format) -> SwapchainCreateInfoKHRBuilder<'a> {
12147         self.inner.image_format = image_format;
12148         self
12149     }
image_color_space( mut self, image_color_space: ColorSpaceKHR, ) -> SwapchainCreateInfoKHRBuilder<'a>12150     pub fn image_color_space(
12151         mut self,
12152         image_color_space: ColorSpaceKHR,
12153     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12154         self.inner.image_color_space = image_color_space;
12155         self
12156     }
image_extent(mut self, image_extent: Extent2D) -> SwapchainCreateInfoKHRBuilder<'a>12157     pub fn image_extent(mut self, image_extent: Extent2D) -> SwapchainCreateInfoKHRBuilder<'a> {
12158         self.inner.image_extent = image_extent;
12159         self
12160     }
image_array_layers( mut self, image_array_layers: u32, ) -> SwapchainCreateInfoKHRBuilder<'a>12161     pub fn image_array_layers(
12162         mut self,
12163         image_array_layers: u32,
12164     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12165         self.inner.image_array_layers = image_array_layers;
12166         self
12167     }
image_usage( mut self, image_usage: ImageUsageFlags, ) -> SwapchainCreateInfoKHRBuilder<'a>12168     pub fn image_usage(
12169         mut self,
12170         image_usage: ImageUsageFlags,
12171     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12172         self.inner.image_usage = image_usage;
12173         self
12174     }
image_sharing_mode( mut self, image_sharing_mode: SharingMode, ) -> SwapchainCreateInfoKHRBuilder<'a>12175     pub fn image_sharing_mode(
12176         mut self,
12177         image_sharing_mode: SharingMode,
12178     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12179         self.inner.image_sharing_mode = image_sharing_mode;
12180         self
12181     }
queue_family_indices( mut self, queue_family_indices: &'a [u32], ) -> SwapchainCreateInfoKHRBuilder<'a>12182     pub fn queue_family_indices(
12183         mut self,
12184         queue_family_indices: &'a [u32],
12185     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12186         self.inner.queue_family_index_count = queue_family_indices.len() as _;
12187         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
12188         self
12189     }
pre_transform( mut self, pre_transform: SurfaceTransformFlagsKHR, ) -> SwapchainCreateInfoKHRBuilder<'a>12190     pub fn pre_transform(
12191         mut self,
12192         pre_transform: SurfaceTransformFlagsKHR,
12193     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12194         self.inner.pre_transform = pre_transform;
12195         self
12196     }
composite_alpha( mut self, composite_alpha: CompositeAlphaFlagsKHR, ) -> SwapchainCreateInfoKHRBuilder<'a>12197     pub fn composite_alpha(
12198         mut self,
12199         composite_alpha: CompositeAlphaFlagsKHR,
12200     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12201         self.inner.composite_alpha = composite_alpha;
12202         self
12203     }
present_mode( mut self, present_mode: PresentModeKHR, ) -> SwapchainCreateInfoKHRBuilder<'a>12204     pub fn present_mode(
12205         mut self,
12206         present_mode: PresentModeKHR,
12207     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12208         self.inner.present_mode = present_mode;
12209         self
12210     }
clipped(mut self, clipped: bool) -> SwapchainCreateInfoKHRBuilder<'a>12211     pub fn clipped(mut self, clipped: bool) -> SwapchainCreateInfoKHRBuilder<'a> {
12212         self.inner.clipped = clipped.into();
12213         self
12214     }
old_swapchain( mut self, old_swapchain: SwapchainKHR, ) -> SwapchainCreateInfoKHRBuilder<'a>12215     pub fn old_swapchain(
12216         mut self,
12217         old_swapchain: SwapchainKHR,
12218     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12219         self.inner.old_swapchain = old_swapchain;
12220         self
12221     }
12222     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
12223     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
12224     #[doc = r" valid extension structs can be pushed into the chain."]
12225     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
12226     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSwapchainCreateInfoKHR>( mut self, next: &'a mut T, ) -> SwapchainCreateInfoKHRBuilder<'a>12227     pub fn push_next<T: ExtendsSwapchainCreateInfoKHR>(
12228         mut self,
12229         next: &'a mut T,
12230     ) -> SwapchainCreateInfoKHRBuilder<'a> {
12231         unsafe {
12232             let next_ptr = next as *mut T as *mut BaseOutStructure;
12233             let last_next = ptr_chain_iter(next).last().unwrap();
12234             (*last_next).p_next = self.inner.p_next as _;
12235             self.inner.p_next = next_ptr as _;
12236         }
12237         self
12238     }
12239     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12240     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12241     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainCreateInfoKHR12242     pub fn build(self) -> SwapchainCreateInfoKHR {
12243         self.inner
12244     }
12245 }
12246 #[repr(C)]
12247 #[derive(Copy, Clone, Debug)]
12248 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentInfoKHR.html>"]
12249 pub struct PresentInfoKHR {
12250     pub s_type: StructureType,
12251     pub p_next: *const c_void,
12252     pub wait_semaphore_count: u32,
12253     pub p_wait_semaphores: *const Semaphore,
12254     pub swapchain_count: u32,
12255     pub p_swapchains: *const SwapchainKHR,
12256     pub p_image_indices: *const u32,
12257     pub p_results: *mut Result,
12258 }
12259 impl ::std::default::Default for PresentInfoKHR {
default() -> PresentInfoKHR12260     fn default() -> PresentInfoKHR {
12261         PresentInfoKHR {
12262             s_type: StructureType::PRESENT_INFO_KHR,
12263             p_next: ::std::ptr::null(),
12264             wait_semaphore_count: u32::default(),
12265             p_wait_semaphores: ::std::ptr::null(),
12266             swapchain_count: u32::default(),
12267             p_swapchains: ::std::ptr::null(),
12268             p_image_indices: ::std::ptr::null(),
12269             p_results: ::std::ptr::null_mut(),
12270         }
12271     }
12272 }
12273 impl PresentInfoKHR {
builder<'a>() -> PresentInfoKHRBuilder<'a>12274     pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> {
12275         PresentInfoKHRBuilder {
12276             inner: PresentInfoKHR::default(),
12277             marker: ::std::marker::PhantomData,
12278         }
12279     }
12280 }
12281 #[repr(transparent)]
12282 pub struct PresentInfoKHRBuilder<'a> {
12283     inner: PresentInfoKHR,
12284     marker: ::std::marker::PhantomData<&'a ()>,
12285 }
12286 pub unsafe trait ExtendsPresentInfoKHR {}
12287 impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> {
12288     type Target = PresentInfoKHR;
deref(&self) -> &Self::Target12289     fn deref(&self) -> &Self::Target {
12290         &self.inner
12291     }
12292 }
12293 impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12294     fn deref_mut(&mut self) -> &mut Self::Target {
12295         &mut self.inner
12296     }
12297 }
12298 impl<'a> PresentInfoKHRBuilder<'a> {
wait_semaphores( mut self, wait_semaphores: &'a [Semaphore], ) -> PresentInfoKHRBuilder<'a>12299     pub fn wait_semaphores(
12300         mut self,
12301         wait_semaphores: &'a [Semaphore],
12302     ) -> PresentInfoKHRBuilder<'a> {
12303         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
12304         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
12305         self
12306     }
swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> PresentInfoKHRBuilder<'a>12307     pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> PresentInfoKHRBuilder<'a> {
12308         self.inner.swapchain_count = swapchains.len() as _;
12309         self.inner.p_swapchains = swapchains.as_ptr();
12310         self
12311     }
image_indices(mut self, image_indices: &'a [u32]) -> PresentInfoKHRBuilder<'a>12312     pub fn image_indices(mut self, image_indices: &'a [u32]) -> PresentInfoKHRBuilder<'a> {
12313         self.inner.swapchain_count = image_indices.len() as _;
12314         self.inner.p_image_indices = image_indices.as_ptr();
12315         self
12316     }
results(mut self, results: &'a mut [Result]) -> PresentInfoKHRBuilder<'a>12317     pub fn results(mut self, results: &'a mut [Result]) -> PresentInfoKHRBuilder<'a> {
12318         self.inner.swapchain_count = results.len() as _;
12319         self.inner.p_results = results.as_mut_ptr();
12320         self
12321     }
12322     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
12323     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
12324     #[doc = r" valid extension structs can be pushed into the chain."]
12325     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
12326     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPresentInfoKHR>( mut self, next: &'a mut T, ) -> PresentInfoKHRBuilder<'a>12327     pub fn push_next<T: ExtendsPresentInfoKHR>(
12328         mut self,
12329         next: &'a mut T,
12330     ) -> PresentInfoKHRBuilder<'a> {
12331         unsafe {
12332             let next_ptr = next as *mut T as *mut BaseOutStructure;
12333             let last_next = ptr_chain_iter(next).last().unwrap();
12334             (*last_next).p_next = self.inner.p_next as _;
12335             self.inner.p_next = next_ptr as _;
12336         }
12337         self
12338     }
12339     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12340     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12341     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentInfoKHR12342     pub fn build(self) -> PresentInfoKHR {
12343         self.inner
12344     }
12345 }
12346 #[repr(C)]
12347 #[derive(Copy, Clone)]
12348 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html>"]
12349 pub struct DebugReportCallbackCreateInfoEXT {
12350     pub s_type: StructureType,
12351     pub p_next: *const c_void,
12352     pub flags: DebugReportFlagsEXT,
12353     pub pfn_callback: PFN_vkDebugReportCallbackEXT,
12354     pub p_user_data: *mut c_void,
12355 }
12356 impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result12357     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
12358         fmt.debug_struct("DebugReportCallbackCreateInfoEXT")
12359             .field("s_type", &self.s_type)
12360             .field("p_next", &self.p_next)
12361             .field("flags", &self.flags)
12362             .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ())))
12363             .field("p_user_data", &self.p_user_data)
12364             .finish()
12365     }
12366 }
12367 impl ::std::default::Default for DebugReportCallbackCreateInfoEXT {
default() -> DebugReportCallbackCreateInfoEXT12368     fn default() -> DebugReportCallbackCreateInfoEXT {
12369         DebugReportCallbackCreateInfoEXT {
12370             s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
12371             p_next: ::std::ptr::null(),
12372             flags: DebugReportFlagsEXT::default(),
12373             pfn_callback: PFN_vkDebugReportCallbackEXT::default(),
12374             p_user_data: ::std::ptr::null_mut(),
12375         }
12376     }
12377 }
12378 impl DebugReportCallbackCreateInfoEXT {
builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a>12379     pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
12380         DebugReportCallbackCreateInfoEXTBuilder {
12381             inner: DebugReportCallbackCreateInfoEXT::default(),
12382             marker: ::std::marker::PhantomData,
12383         }
12384     }
12385 }
12386 #[repr(transparent)]
12387 pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> {
12388     inner: DebugReportCallbackCreateInfoEXT,
12389     marker: ::std::marker::PhantomData<&'a ()>,
12390 }
12391 unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {}
12392 unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {}
12393 impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> {
12394     type Target = DebugReportCallbackCreateInfoEXT;
deref(&self) -> &Self::Target12395     fn deref(&self) -> &Self::Target {
12396         &self.inner
12397     }
12398 }
12399 impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12400     fn deref_mut(&mut self) -> &mut Self::Target {
12401         &mut self.inner
12402     }
12403 }
12404 impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
flags( mut self, flags: DebugReportFlagsEXT, ) -> DebugReportCallbackCreateInfoEXTBuilder<'a>12405     pub fn flags(
12406         mut self,
12407         flags: DebugReportFlagsEXT,
12408     ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
12409         self.inner.flags = flags;
12410         self
12411     }
pfn_callback( mut self, pfn_callback: PFN_vkDebugReportCallbackEXT, ) -> DebugReportCallbackCreateInfoEXTBuilder<'a>12412     pub fn pfn_callback(
12413         mut self,
12414         pfn_callback: PFN_vkDebugReportCallbackEXT,
12415     ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
12416         self.inner.pfn_callback = pfn_callback;
12417         self
12418     }
user_data( mut self, user_data: *mut c_void, ) -> DebugReportCallbackCreateInfoEXTBuilder<'a>12419     pub fn user_data(
12420         mut self,
12421         user_data: *mut c_void,
12422     ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
12423         self.inner.p_user_data = user_data;
12424         self
12425     }
12426     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12427     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12428     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugReportCallbackCreateInfoEXT12429     pub fn build(self) -> DebugReportCallbackCreateInfoEXT {
12430         self.inner
12431     }
12432 }
12433 #[repr(C)]
12434 #[derive(Copy, Clone, Debug)]
12435 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFlagsEXT.html>"]
12436 pub struct ValidationFlagsEXT {
12437     pub s_type: StructureType,
12438     pub p_next: *const c_void,
12439     pub disabled_validation_check_count: u32,
12440     pub p_disabled_validation_checks: *const ValidationCheckEXT,
12441 }
12442 impl ::std::default::Default for ValidationFlagsEXT {
default() -> ValidationFlagsEXT12443     fn default() -> ValidationFlagsEXT {
12444         ValidationFlagsEXT {
12445             s_type: StructureType::VALIDATION_FLAGS_EXT,
12446             p_next: ::std::ptr::null(),
12447             disabled_validation_check_count: u32::default(),
12448             p_disabled_validation_checks: ::std::ptr::null(),
12449         }
12450     }
12451 }
12452 impl ValidationFlagsEXT {
builder<'a>() -> ValidationFlagsEXTBuilder<'a>12453     pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> {
12454         ValidationFlagsEXTBuilder {
12455             inner: ValidationFlagsEXT::default(),
12456             marker: ::std::marker::PhantomData,
12457         }
12458     }
12459 }
12460 #[repr(transparent)]
12461 pub struct ValidationFlagsEXTBuilder<'a> {
12462     inner: ValidationFlagsEXT,
12463     marker: ::std::marker::PhantomData<&'a ()>,
12464 }
12465 unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {}
12466 unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {}
12467 impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> {
12468     type Target = ValidationFlagsEXT;
deref(&self) -> &Self::Target12469     fn deref(&self) -> &Self::Target {
12470         &self.inner
12471     }
12472 }
12473 impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12474     fn deref_mut(&mut self) -> &mut Self::Target {
12475         &mut self.inner
12476     }
12477 }
12478 impl<'a> ValidationFlagsEXTBuilder<'a> {
disabled_validation_checks( mut self, disabled_validation_checks: &'a [ValidationCheckEXT], ) -> ValidationFlagsEXTBuilder<'a>12479     pub fn disabled_validation_checks(
12480         mut self,
12481         disabled_validation_checks: &'a [ValidationCheckEXT],
12482     ) -> ValidationFlagsEXTBuilder<'a> {
12483         self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _;
12484         self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr();
12485         self
12486     }
12487     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12488     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12489     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ValidationFlagsEXT12490     pub fn build(self) -> ValidationFlagsEXT {
12491         self.inner
12492     }
12493 }
12494 #[repr(C)]
12495 #[derive(Copy, Clone, Debug)]
12496 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFeaturesEXT.html>"]
12497 pub struct ValidationFeaturesEXT {
12498     pub s_type: StructureType,
12499     pub p_next: *const c_void,
12500     pub enabled_validation_feature_count: u32,
12501     pub p_enabled_validation_features: *const ValidationFeatureEnableEXT,
12502     pub disabled_validation_feature_count: u32,
12503     pub p_disabled_validation_features: *const ValidationFeatureDisableEXT,
12504 }
12505 impl ::std::default::Default for ValidationFeaturesEXT {
default() -> ValidationFeaturesEXT12506     fn default() -> ValidationFeaturesEXT {
12507         ValidationFeaturesEXT {
12508             s_type: StructureType::VALIDATION_FEATURES_EXT,
12509             p_next: ::std::ptr::null(),
12510             enabled_validation_feature_count: u32::default(),
12511             p_enabled_validation_features: ::std::ptr::null(),
12512             disabled_validation_feature_count: u32::default(),
12513             p_disabled_validation_features: ::std::ptr::null(),
12514         }
12515     }
12516 }
12517 impl ValidationFeaturesEXT {
builder<'a>() -> ValidationFeaturesEXTBuilder<'a>12518     pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> {
12519         ValidationFeaturesEXTBuilder {
12520             inner: ValidationFeaturesEXT::default(),
12521             marker: ::std::marker::PhantomData,
12522         }
12523     }
12524 }
12525 #[repr(transparent)]
12526 pub struct ValidationFeaturesEXTBuilder<'a> {
12527     inner: ValidationFeaturesEXT,
12528     marker: ::std::marker::PhantomData<&'a ()>,
12529 }
12530 unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {}
12531 unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {}
12532 impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> {
12533     type Target = ValidationFeaturesEXT;
deref(&self) -> &Self::Target12534     fn deref(&self) -> &Self::Target {
12535         &self.inner
12536     }
12537 }
12538 impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12539     fn deref_mut(&mut self) -> &mut Self::Target {
12540         &mut self.inner
12541     }
12542 }
12543 impl<'a> ValidationFeaturesEXTBuilder<'a> {
enabled_validation_features( mut self, enabled_validation_features: &'a [ValidationFeatureEnableEXT], ) -> ValidationFeaturesEXTBuilder<'a>12544     pub fn enabled_validation_features(
12545         mut self,
12546         enabled_validation_features: &'a [ValidationFeatureEnableEXT],
12547     ) -> ValidationFeaturesEXTBuilder<'a> {
12548         self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _;
12549         self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr();
12550         self
12551     }
disabled_validation_features( mut self, disabled_validation_features: &'a [ValidationFeatureDisableEXT], ) -> ValidationFeaturesEXTBuilder<'a>12552     pub fn disabled_validation_features(
12553         mut self,
12554         disabled_validation_features: &'a [ValidationFeatureDisableEXT],
12555     ) -> ValidationFeaturesEXTBuilder<'a> {
12556         self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _;
12557         self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr();
12558         self
12559     }
12560     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12561     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12562     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ValidationFeaturesEXT12563     pub fn build(self) -> ValidationFeaturesEXT {
12564         self.inner
12565     }
12566 }
12567 #[repr(C)]
12568 #[derive(Copy, Clone, Debug)]
12569 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>"]
12570 pub struct PipelineRasterizationStateRasterizationOrderAMD {
12571     pub s_type: StructureType,
12572     pub p_next: *const c_void,
12573     pub rasterization_order: RasterizationOrderAMD,
12574 }
12575 impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD {
default() -> PipelineRasterizationStateRasterizationOrderAMD12576     fn default() -> PipelineRasterizationStateRasterizationOrderAMD {
12577         PipelineRasterizationStateRasterizationOrderAMD {
12578             s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
12579             p_next: ::std::ptr::null(),
12580             rasterization_order: RasterizationOrderAMD::default(),
12581         }
12582     }
12583 }
12584 impl PipelineRasterizationStateRasterizationOrderAMD {
builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a>12585     pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12586         PipelineRasterizationStateRasterizationOrderAMDBuilder {
12587             inner: PipelineRasterizationStateRasterizationOrderAMD::default(),
12588             marker: ::std::marker::PhantomData,
12589         }
12590     }
12591 }
12592 #[repr(transparent)]
12593 pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12594     inner: PipelineRasterizationStateRasterizationOrderAMD,
12595     marker: ::std::marker::PhantomData<&'a ()>,
12596 }
12597 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
12598     for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_>
12599 {
12600 }
12601 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
12602     for PipelineRasterizationStateRasterizationOrderAMD
12603 {
12604 }
12605 impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12606     type Target = PipelineRasterizationStateRasterizationOrderAMD;
deref(&self) -> &Self::Target12607     fn deref(&self) -> &Self::Target {
12608         &self.inner
12609     }
12610 }
12611 impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12612     fn deref_mut(&mut self) -> &mut Self::Target {
12613         &mut self.inner
12614     }
12615 }
12616 impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
rasterization_order( mut self, rasterization_order: RasterizationOrderAMD, ) -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a>12617     pub fn rasterization_order(
12618         mut self,
12619         rasterization_order: RasterizationOrderAMD,
12620     ) -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
12621         self.inner.rasterization_order = rasterization_order;
12622         self
12623     }
12624     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12625     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12626     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationStateRasterizationOrderAMD12627     pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD {
12628         self.inner
12629     }
12630 }
12631 #[repr(C)]
12632 #[derive(Copy, Clone, Debug)]
12633 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html>"]
12634 pub struct DebugMarkerObjectNameInfoEXT {
12635     pub s_type: StructureType,
12636     pub p_next: *const c_void,
12637     pub object_type: DebugReportObjectTypeEXT,
12638     pub object: u64,
12639     pub p_object_name: *const c_char,
12640 }
12641 impl ::std::default::Default for DebugMarkerObjectNameInfoEXT {
default() -> DebugMarkerObjectNameInfoEXT12642     fn default() -> DebugMarkerObjectNameInfoEXT {
12643         DebugMarkerObjectNameInfoEXT {
12644             s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
12645             p_next: ::std::ptr::null(),
12646             object_type: DebugReportObjectTypeEXT::default(),
12647             object: u64::default(),
12648             p_object_name: ::std::ptr::null(),
12649         }
12650     }
12651 }
12652 impl DebugMarkerObjectNameInfoEXT {
builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a>12653     pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
12654         DebugMarkerObjectNameInfoEXTBuilder {
12655             inner: DebugMarkerObjectNameInfoEXT::default(),
12656             marker: ::std::marker::PhantomData,
12657         }
12658     }
12659 }
12660 #[repr(transparent)]
12661 pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> {
12662     inner: DebugMarkerObjectNameInfoEXT,
12663     marker: ::std::marker::PhantomData<&'a ()>,
12664 }
12665 pub unsafe trait ExtendsDebugMarkerObjectNameInfoEXT {}
12666 impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> {
12667     type Target = DebugMarkerObjectNameInfoEXT;
deref(&self) -> &Self::Target12668     fn deref(&self) -> &Self::Target {
12669         &self.inner
12670     }
12671 }
12672 impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12673     fn deref_mut(&mut self) -> &mut Self::Target {
12674         &mut self.inner
12675     }
12676 }
12677 impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
object_type( mut self, object_type: DebugReportObjectTypeEXT, ) -> DebugMarkerObjectNameInfoEXTBuilder<'a>12678     pub fn object_type(
12679         mut self,
12680         object_type: DebugReportObjectTypeEXT,
12681     ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
12682         self.inner.object_type = object_type;
12683         self
12684     }
object(mut self, object: u64) -> DebugMarkerObjectNameInfoEXTBuilder<'a>12685     pub fn object(mut self, object: u64) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
12686         self.inner.object = object;
12687         self
12688     }
object_name( mut self, object_name: &'a ::std::ffi::CStr, ) -> DebugMarkerObjectNameInfoEXTBuilder<'a>12689     pub fn object_name(
12690         mut self,
12691         object_name: &'a ::std::ffi::CStr,
12692     ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
12693         self.inner.p_object_name = object_name.as_ptr();
12694         self
12695     }
12696     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
12697     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
12698     #[doc = r" valid extension structs can be pushed into the chain."]
12699     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
12700     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugMarkerObjectNameInfoEXT>( mut self, next: &'a mut T, ) -> DebugMarkerObjectNameInfoEXTBuilder<'a>12701     pub fn push_next<T: ExtendsDebugMarkerObjectNameInfoEXT>(
12702         mut self,
12703         next: &'a mut T,
12704     ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
12705         unsafe {
12706             let next_ptr = next as *mut T as *mut BaseOutStructure;
12707             let last_next = ptr_chain_iter(next).last().unwrap();
12708             (*last_next).p_next = self.inner.p_next as _;
12709             self.inner.p_next = next_ptr as _;
12710         }
12711         self
12712     }
12713     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12714     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12715     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugMarkerObjectNameInfoEXT12716     pub fn build(self) -> DebugMarkerObjectNameInfoEXT {
12717         self.inner
12718     }
12719 }
12720 #[repr(C)]
12721 #[derive(Copy, Clone, Debug)]
12722 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html>"]
12723 pub struct DebugMarkerObjectTagInfoEXT {
12724     pub s_type: StructureType,
12725     pub p_next: *const c_void,
12726     pub object_type: DebugReportObjectTypeEXT,
12727     pub object: u64,
12728     pub tag_name: u64,
12729     pub tag_size: usize,
12730     pub p_tag: *const c_void,
12731 }
12732 impl ::std::default::Default for DebugMarkerObjectTagInfoEXT {
default() -> DebugMarkerObjectTagInfoEXT12733     fn default() -> DebugMarkerObjectTagInfoEXT {
12734         DebugMarkerObjectTagInfoEXT {
12735             s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
12736             p_next: ::std::ptr::null(),
12737             object_type: DebugReportObjectTypeEXT::default(),
12738             object: u64::default(),
12739             tag_name: u64::default(),
12740             tag_size: usize::default(),
12741             p_tag: ::std::ptr::null(),
12742         }
12743     }
12744 }
12745 impl DebugMarkerObjectTagInfoEXT {
builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a>12746     pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12747         DebugMarkerObjectTagInfoEXTBuilder {
12748             inner: DebugMarkerObjectTagInfoEXT::default(),
12749             marker: ::std::marker::PhantomData,
12750         }
12751     }
12752 }
12753 #[repr(transparent)]
12754 pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> {
12755     inner: DebugMarkerObjectTagInfoEXT,
12756     marker: ::std::marker::PhantomData<&'a ()>,
12757 }
12758 pub unsafe trait ExtendsDebugMarkerObjectTagInfoEXT {}
12759 impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> {
12760     type Target = DebugMarkerObjectTagInfoEXT;
deref(&self) -> &Self::Target12761     fn deref(&self) -> &Self::Target {
12762         &self.inner
12763     }
12764 }
12765 impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12766     fn deref_mut(&mut self) -> &mut Self::Target {
12767         &mut self.inner
12768     }
12769 }
12770 impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
object_type( mut self, object_type: DebugReportObjectTypeEXT, ) -> DebugMarkerObjectTagInfoEXTBuilder<'a>12771     pub fn object_type(
12772         mut self,
12773         object_type: DebugReportObjectTypeEXT,
12774     ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12775         self.inner.object_type = object_type;
12776         self
12777     }
object(mut self, object: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a>12778     pub fn object(mut self, object: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12779         self.inner.object = object;
12780         self
12781     }
tag_name(mut self, tag_name: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a>12782     pub fn tag_name(mut self, tag_name: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12783         self.inner.tag_name = tag_name;
12784         self
12785     }
tag(mut self, tag: &'a [u8]) -> DebugMarkerObjectTagInfoEXTBuilder<'a>12786     pub fn tag(mut self, tag: &'a [u8]) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12787         self.inner.tag_size = tag.len() as _;
12788         self.inner.p_tag = tag.as_ptr() as *const c_void;
12789         self
12790     }
12791     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
12792     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
12793     #[doc = r" valid extension structs can be pushed into the chain."]
12794     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
12795     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugMarkerObjectTagInfoEXT>( mut self, next: &'a mut T, ) -> DebugMarkerObjectTagInfoEXTBuilder<'a>12796     pub fn push_next<T: ExtendsDebugMarkerObjectTagInfoEXT>(
12797         mut self,
12798         next: &'a mut T,
12799     ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
12800         unsafe {
12801             let next_ptr = next as *mut T as *mut BaseOutStructure;
12802             let last_next = ptr_chain_iter(next).last().unwrap();
12803             (*last_next).p_next = self.inner.p_next as _;
12804             self.inner.p_next = next_ptr as _;
12805         }
12806         self
12807     }
12808     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12809     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12810     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugMarkerObjectTagInfoEXT12811     pub fn build(self) -> DebugMarkerObjectTagInfoEXT {
12812         self.inner
12813     }
12814 }
12815 #[repr(C)]
12816 #[derive(Copy, Clone, Debug)]
12817 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html>"]
12818 pub struct DebugMarkerMarkerInfoEXT {
12819     pub s_type: StructureType,
12820     pub p_next: *const c_void,
12821     pub p_marker_name: *const c_char,
12822     pub color: [f32; 4],
12823 }
12824 impl ::std::default::Default for DebugMarkerMarkerInfoEXT {
default() -> DebugMarkerMarkerInfoEXT12825     fn default() -> DebugMarkerMarkerInfoEXT {
12826         DebugMarkerMarkerInfoEXT {
12827             s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT,
12828             p_next: ::std::ptr::null(),
12829             p_marker_name: ::std::ptr::null(),
12830             color: unsafe { ::std::mem::zeroed() },
12831         }
12832     }
12833 }
12834 impl DebugMarkerMarkerInfoEXT {
builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a>12835     pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> {
12836         DebugMarkerMarkerInfoEXTBuilder {
12837             inner: DebugMarkerMarkerInfoEXT::default(),
12838             marker: ::std::marker::PhantomData,
12839         }
12840     }
12841 }
12842 #[repr(transparent)]
12843 pub struct DebugMarkerMarkerInfoEXTBuilder<'a> {
12844     inner: DebugMarkerMarkerInfoEXT,
12845     marker: ::std::marker::PhantomData<&'a ()>,
12846 }
12847 pub unsafe trait ExtendsDebugMarkerMarkerInfoEXT {}
12848 impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> {
12849     type Target = DebugMarkerMarkerInfoEXT;
deref(&self) -> &Self::Target12850     fn deref(&self) -> &Self::Target {
12851         &self.inner
12852     }
12853 }
12854 impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12855     fn deref_mut(&mut self) -> &mut Self::Target {
12856         &mut self.inner
12857     }
12858 }
12859 impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
marker_name( mut self, marker_name: &'a ::std::ffi::CStr, ) -> DebugMarkerMarkerInfoEXTBuilder<'a>12860     pub fn marker_name(
12861         mut self,
12862         marker_name: &'a ::std::ffi::CStr,
12863     ) -> DebugMarkerMarkerInfoEXTBuilder<'a> {
12864         self.inner.p_marker_name = marker_name.as_ptr();
12865         self
12866     }
color(mut self, color: [f32; 4]) -> DebugMarkerMarkerInfoEXTBuilder<'a>12867     pub fn color(mut self, color: [f32; 4]) -> DebugMarkerMarkerInfoEXTBuilder<'a> {
12868         self.inner.color = color;
12869         self
12870     }
12871     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
12872     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
12873     #[doc = r" valid extension structs can be pushed into the chain."]
12874     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
12875     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugMarkerMarkerInfoEXT>( mut self, next: &'a mut T, ) -> DebugMarkerMarkerInfoEXTBuilder<'a>12876     pub fn push_next<T: ExtendsDebugMarkerMarkerInfoEXT>(
12877         mut self,
12878         next: &'a mut T,
12879     ) -> DebugMarkerMarkerInfoEXTBuilder<'a> {
12880         unsafe {
12881             let next_ptr = next as *mut T as *mut BaseOutStructure;
12882             let last_next = ptr_chain_iter(next).last().unwrap();
12883             (*last_next).p_next = self.inner.p_next as _;
12884             self.inner.p_next = next_ptr as _;
12885         }
12886         self
12887     }
12888     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12889     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12890     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugMarkerMarkerInfoEXT12891     pub fn build(self) -> DebugMarkerMarkerInfoEXT {
12892         self.inner
12893     }
12894 }
12895 #[repr(C)]
12896 #[derive(Copy, Clone, Debug)]
12897 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html>"]
12898 pub struct DedicatedAllocationImageCreateInfoNV {
12899     pub s_type: StructureType,
12900     pub p_next: *const c_void,
12901     pub dedicated_allocation: Bool32,
12902 }
12903 impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV {
default() -> DedicatedAllocationImageCreateInfoNV12904     fn default() -> DedicatedAllocationImageCreateInfoNV {
12905         DedicatedAllocationImageCreateInfoNV {
12906             s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
12907             p_next: ::std::ptr::null(),
12908             dedicated_allocation: Bool32::default(),
12909         }
12910     }
12911 }
12912 impl DedicatedAllocationImageCreateInfoNV {
builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a>12913     pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
12914         DedicatedAllocationImageCreateInfoNVBuilder {
12915             inner: DedicatedAllocationImageCreateInfoNV::default(),
12916             marker: ::std::marker::PhantomData,
12917         }
12918     }
12919 }
12920 #[repr(transparent)]
12921 pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> {
12922     inner: DedicatedAllocationImageCreateInfoNV,
12923     marker: ::std::marker::PhantomData<&'a ()>,
12924 }
12925 unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {}
12926 unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {}
12927 impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
12928     type Target = DedicatedAllocationImageCreateInfoNV;
deref(&self) -> &Self::Target12929     fn deref(&self) -> &Self::Target {
12930         &self.inner
12931     }
12932 }
12933 impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12934     fn deref_mut(&mut self) -> &mut Self::Target {
12935         &mut self.inner
12936     }
12937 }
12938 impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
dedicated_allocation( mut self, dedicated_allocation: bool, ) -> DedicatedAllocationImageCreateInfoNVBuilder<'a>12939     pub fn dedicated_allocation(
12940         mut self,
12941         dedicated_allocation: bool,
12942     ) -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
12943         self.inner.dedicated_allocation = dedicated_allocation.into();
12944         self
12945     }
12946     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
12947     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
12948     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DedicatedAllocationImageCreateInfoNV12949     pub fn build(self) -> DedicatedAllocationImageCreateInfoNV {
12950         self.inner
12951     }
12952 }
12953 #[repr(C)]
12954 #[derive(Copy, Clone, Debug)]
12955 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>"]
12956 pub struct DedicatedAllocationBufferCreateInfoNV {
12957     pub s_type: StructureType,
12958     pub p_next: *const c_void,
12959     pub dedicated_allocation: Bool32,
12960 }
12961 impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV {
default() -> DedicatedAllocationBufferCreateInfoNV12962     fn default() -> DedicatedAllocationBufferCreateInfoNV {
12963         DedicatedAllocationBufferCreateInfoNV {
12964             s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
12965             p_next: ::std::ptr::null(),
12966             dedicated_allocation: Bool32::default(),
12967         }
12968     }
12969 }
12970 impl DedicatedAllocationBufferCreateInfoNV {
builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a>12971     pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
12972         DedicatedAllocationBufferCreateInfoNVBuilder {
12973             inner: DedicatedAllocationBufferCreateInfoNV::default(),
12974             marker: ::std::marker::PhantomData,
12975         }
12976     }
12977 }
12978 #[repr(transparent)]
12979 pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
12980     inner: DedicatedAllocationBufferCreateInfoNV,
12981     marker: ::std::marker::PhantomData<&'a ()>,
12982 }
12983 unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {}
12984 unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {}
12985 impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
12986     type Target = DedicatedAllocationBufferCreateInfoNV;
deref(&self) -> &Self::Target12987     fn deref(&self) -> &Self::Target {
12988         &self.inner
12989     }
12990 }
12991 impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target12992     fn deref_mut(&mut self) -> &mut Self::Target {
12993         &mut self.inner
12994     }
12995 }
12996 impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
dedicated_allocation( mut self, dedicated_allocation: bool, ) -> DedicatedAllocationBufferCreateInfoNVBuilder<'a>12997     pub fn dedicated_allocation(
12998         mut self,
12999         dedicated_allocation: bool,
13000     ) -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
13001         self.inner.dedicated_allocation = dedicated_allocation.into();
13002         self
13003     }
13004     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13005     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13006     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DedicatedAllocationBufferCreateInfoNV13007     pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV {
13008         self.inner
13009     }
13010 }
13011 #[repr(C)]
13012 #[derive(Copy, Clone, Debug)]
13013 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>"]
13014 pub struct DedicatedAllocationMemoryAllocateInfoNV {
13015     pub s_type: StructureType,
13016     pub p_next: *const c_void,
13017     pub image: Image,
13018     pub buffer: Buffer,
13019 }
13020 impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV {
default() -> DedicatedAllocationMemoryAllocateInfoNV13021     fn default() -> DedicatedAllocationMemoryAllocateInfoNV {
13022         DedicatedAllocationMemoryAllocateInfoNV {
13023             s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
13024             p_next: ::std::ptr::null(),
13025             image: Image::default(),
13026             buffer: Buffer::default(),
13027         }
13028     }
13029 }
13030 impl DedicatedAllocationMemoryAllocateInfoNV {
builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a>13031     pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13032         DedicatedAllocationMemoryAllocateInfoNVBuilder {
13033             inner: DedicatedAllocationMemoryAllocateInfoNV::default(),
13034             marker: ::std::marker::PhantomData,
13035         }
13036     }
13037 }
13038 #[repr(transparent)]
13039 pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13040     inner: DedicatedAllocationMemoryAllocateInfoNV,
13041     marker: ::std::marker::PhantomData<&'a ()>,
13042 }
13043 unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {}
13044 unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {}
13045 impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13046     type Target = DedicatedAllocationMemoryAllocateInfoNV;
deref(&self) -> &Self::Target13047     fn deref(&self) -> &Self::Target {
13048         &self.inner
13049     }
13050 }
13051 impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13052     fn deref_mut(&mut self) -> &mut Self::Target {
13053         &mut self.inner
13054     }
13055 }
13056 impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
image(mut self, image: Image) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a>13057     pub fn image(mut self, image: Image) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13058         self.inner.image = image;
13059         self
13060     }
buffer(mut self, buffer: Buffer) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a>13061     pub fn buffer(mut self, buffer: Buffer) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
13062         self.inner.buffer = buffer;
13063         self
13064     }
13065     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13066     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13067     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DedicatedAllocationMemoryAllocateInfoNV13068     pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV {
13069         self.inner
13070     }
13071 }
13072 #[repr(C)]
13073 #[derive(Copy, Clone, Default, Debug)]
13074 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalImageFormatPropertiesNV.html>"]
13075 pub struct ExternalImageFormatPropertiesNV {
13076     pub image_format_properties: ImageFormatProperties,
13077     pub external_memory_features: ExternalMemoryFeatureFlagsNV,
13078     pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
13079     pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
13080 }
13081 impl ExternalImageFormatPropertiesNV {
builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a>13082     pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> {
13083         ExternalImageFormatPropertiesNVBuilder {
13084             inner: ExternalImageFormatPropertiesNV::default(),
13085             marker: ::std::marker::PhantomData,
13086         }
13087     }
13088 }
13089 #[repr(transparent)]
13090 pub struct ExternalImageFormatPropertiesNVBuilder<'a> {
13091     inner: ExternalImageFormatPropertiesNV,
13092     marker: ::std::marker::PhantomData<&'a ()>,
13093 }
13094 impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> {
13095     type Target = ExternalImageFormatPropertiesNV;
deref(&self) -> &Self::Target13096     fn deref(&self) -> &Self::Target {
13097         &self.inner
13098     }
13099 }
13100 impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13101     fn deref_mut(&mut self) -> &mut Self::Target {
13102         &mut self.inner
13103     }
13104 }
13105 impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
image_format_properties( mut self, image_format_properties: ImageFormatProperties, ) -> ExternalImageFormatPropertiesNVBuilder<'a>13106     pub fn image_format_properties(
13107         mut self,
13108         image_format_properties: ImageFormatProperties,
13109     ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
13110         self.inner.image_format_properties = image_format_properties;
13111         self
13112     }
external_memory_features( mut self, external_memory_features: ExternalMemoryFeatureFlagsNV, ) -> ExternalImageFormatPropertiesNVBuilder<'a>13113     pub fn external_memory_features(
13114         mut self,
13115         external_memory_features: ExternalMemoryFeatureFlagsNV,
13116     ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
13117         self.inner.external_memory_features = external_memory_features;
13118         self
13119     }
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> ExternalImageFormatPropertiesNVBuilder<'a>13120     pub fn export_from_imported_handle_types(
13121         mut self,
13122         export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
13123     ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
13124         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
13125         self
13126     }
compatible_handle_types( mut self, compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> ExternalImageFormatPropertiesNVBuilder<'a>13127     pub fn compatible_handle_types(
13128         mut self,
13129         compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
13130     ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
13131         self.inner.compatible_handle_types = compatible_handle_types;
13132         self
13133     }
13134     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13135     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13136     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalImageFormatPropertiesNV13137     pub fn build(self) -> ExternalImageFormatPropertiesNV {
13138         self.inner
13139     }
13140 }
13141 #[repr(C)]
13142 #[derive(Copy, Clone, Debug)]
13143 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html>"]
13144 pub struct ExternalMemoryImageCreateInfoNV {
13145     pub s_type: StructureType,
13146     pub p_next: *const c_void,
13147     pub handle_types: ExternalMemoryHandleTypeFlagsNV,
13148 }
13149 impl ::std::default::Default for ExternalMemoryImageCreateInfoNV {
default() -> ExternalMemoryImageCreateInfoNV13150     fn default() -> ExternalMemoryImageCreateInfoNV {
13151         ExternalMemoryImageCreateInfoNV {
13152             s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
13153             p_next: ::std::ptr::null(),
13154             handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
13155         }
13156     }
13157 }
13158 impl ExternalMemoryImageCreateInfoNV {
builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a>13159     pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
13160         ExternalMemoryImageCreateInfoNVBuilder {
13161             inner: ExternalMemoryImageCreateInfoNV::default(),
13162             marker: ::std::marker::PhantomData,
13163         }
13164     }
13165 }
13166 #[repr(transparent)]
13167 pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> {
13168     inner: ExternalMemoryImageCreateInfoNV,
13169     marker: ::std::marker::PhantomData<&'a ()>,
13170 }
13171 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {}
13172 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {}
13173 impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> {
13174     type Target = ExternalMemoryImageCreateInfoNV;
deref(&self) -> &Self::Target13175     fn deref(&self) -> &Self::Target {
13176         &self.inner
13177     }
13178 }
13179 impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13180     fn deref_mut(&mut self) -> &mut Self::Target {
13181         &mut self.inner
13182     }
13183 }
13184 impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
handle_types( mut self, handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> ExternalMemoryImageCreateInfoNVBuilder<'a>13185     pub fn handle_types(
13186         mut self,
13187         handle_types: ExternalMemoryHandleTypeFlagsNV,
13188     ) -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
13189         self.inner.handle_types = handle_types;
13190         self
13191     }
13192     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13193     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13194     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryImageCreateInfoNV13195     pub fn build(self) -> ExternalMemoryImageCreateInfoNV {
13196         self.inner
13197     }
13198 }
13199 #[repr(C)]
13200 #[derive(Copy, Clone, Debug)]
13201 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryAllocateInfoNV.html>"]
13202 pub struct ExportMemoryAllocateInfoNV {
13203     pub s_type: StructureType,
13204     pub p_next: *const c_void,
13205     pub handle_types: ExternalMemoryHandleTypeFlagsNV,
13206 }
13207 impl ::std::default::Default for ExportMemoryAllocateInfoNV {
default() -> ExportMemoryAllocateInfoNV13208     fn default() -> ExportMemoryAllocateInfoNV {
13209         ExportMemoryAllocateInfoNV {
13210             s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV,
13211             p_next: ::std::ptr::null(),
13212             handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
13213         }
13214     }
13215 }
13216 impl ExportMemoryAllocateInfoNV {
builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a>13217     pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> {
13218         ExportMemoryAllocateInfoNVBuilder {
13219             inner: ExportMemoryAllocateInfoNV::default(),
13220             marker: ::std::marker::PhantomData,
13221         }
13222     }
13223 }
13224 #[repr(transparent)]
13225 pub struct ExportMemoryAllocateInfoNVBuilder<'a> {
13226     inner: ExportMemoryAllocateInfoNV,
13227     marker: ::std::marker::PhantomData<&'a ()>,
13228 }
13229 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {}
13230 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {}
13231 impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> {
13232     type Target = ExportMemoryAllocateInfoNV;
deref(&self) -> &Self::Target13233     fn deref(&self) -> &Self::Target {
13234         &self.inner
13235     }
13236 }
13237 impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13238     fn deref_mut(&mut self) -> &mut Self::Target {
13239         &mut self.inner
13240     }
13241 }
13242 impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
handle_types( mut self, handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> ExportMemoryAllocateInfoNVBuilder<'a>13243     pub fn handle_types(
13244         mut self,
13245         handle_types: ExternalMemoryHandleTypeFlagsNV,
13246     ) -> ExportMemoryAllocateInfoNVBuilder<'a> {
13247         self.inner.handle_types = handle_types;
13248         self
13249     }
13250     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13251     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13252     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryAllocateInfoNV13253     pub fn build(self) -> ExportMemoryAllocateInfoNV {
13254         self.inner
13255     }
13256 }
13257 #[repr(C)]
13258 #[derive(Copy, Clone, Debug)]
13259 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html>"]
13260 pub struct ImportMemoryWin32HandleInfoNV {
13261     pub s_type: StructureType,
13262     pub p_next: *const c_void,
13263     pub handle_type: ExternalMemoryHandleTypeFlagsNV,
13264     pub handle: HANDLE,
13265 }
13266 impl ::std::default::Default for ImportMemoryWin32HandleInfoNV {
default() -> ImportMemoryWin32HandleInfoNV13267     fn default() -> ImportMemoryWin32HandleInfoNV {
13268         ImportMemoryWin32HandleInfoNV {
13269             s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
13270             p_next: ::std::ptr::null(),
13271             handle_type: ExternalMemoryHandleTypeFlagsNV::default(),
13272             handle: unsafe { ::std::mem::zeroed() },
13273         }
13274     }
13275 }
13276 impl ImportMemoryWin32HandleInfoNV {
builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a>13277     pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
13278         ImportMemoryWin32HandleInfoNVBuilder {
13279             inner: ImportMemoryWin32HandleInfoNV::default(),
13280             marker: ::std::marker::PhantomData,
13281         }
13282     }
13283 }
13284 #[repr(transparent)]
13285 pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> {
13286     inner: ImportMemoryWin32HandleInfoNV,
13287     marker: ::std::marker::PhantomData<&'a ()>,
13288 }
13289 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {}
13290 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {}
13291 impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> {
13292     type Target = ImportMemoryWin32HandleInfoNV;
deref(&self) -> &Self::Target13293     fn deref(&self) -> &Self::Target {
13294         &self.inner
13295     }
13296 }
13297 impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13298     fn deref_mut(&mut self) -> &mut Self::Target {
13299         &mut self.inner
13300     }
13301 }
13302 impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlagsNV, ) -> ImportMemoryWin32HandleInfoNVBuilder<'a>13303     pub fn handle_type(
13304         mut self,
13305         handle_type: ExternalMemoryHandleTypeFlagsNV,
13306     ) -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
13307         self.inner.handle_type = handle_type;
13308         self
13309     }
handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoNVBuilder<'a>13310     pub fn handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
13311         self.inner.handle = handle;
13312         self
13313     }
13314     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13315     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13316     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryWin32HandleInfoNV13317     pub fn build(self) -> ImportMemoryWin32HandleInfoNV {
13318         self.inner
13319     }
13320 }
13321 #[repr(C)]
13322 #[derive(Copy, Clone, Debug)]
13323 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html>"]
13324 pub struct ExportMemoryWin32HandleInfoNV {
13325     pub s_type: StructureType,
13326     pub p_next: *const c_void,
13327     pub p_attributes: *const SECURITY_ATTRIBUTES,
13328     pub dw_access: DWORD,
13329 }
13330 impl ::std::default::Default for ExportMemoryWin32HandleInfoNV {
default() -> ExportMemoryWin32HandleInfoNV13331     fn default() -> ExportMemoryWin32HandleInfoNV {
13332         ExportMemoryWin32HandleInfoNV {
13333             s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
13334             p_next: ::std::ptr::null(),
13335             p_attributes: ::std::ptr::null(),
13336             dw_access: DWORD::default(),
13337         }
13338     }
13339 }
13340 impl ExportMemoryWin32HandleInfoNV {
builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a>13341     pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
13342         ExportMemoryWin32HandleInfoNVBuilder {
13343             inner: ExportMemoryWin32HandleInfoNV::default(),
13344             marker: ::std::marker::PhantomData,
13345         }
13346     }
13347 }
13348 #[repr(transparent)]
13349 pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> {
13350     inner: ExportMemoryWin32HandleInfoNV,
13351     marker: ::std::marker::PhantomData<&'a ()>,
13352 }
13353 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {}
13354 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {}
13355 impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> {
13356     type Target = ExportMemoryWin32HandleInfoNV;
deref(&self) -> &Self::Target13357     fn deref(&self) -> &Self::Target {
13358         &self.inner
13359     }
13360 }
13361 impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13362     fn deref_mut(&mut self) -> &mut Self::Target {
13363         &mut self.inner
13364     }
13365 }
13366 impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
attributes( mut self, attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportMemoryWin32HandleInfoNVBuilder<'a>13367     pub fn attributes(
13368         mut self,
13369         attributes: &'a SECURITY_ATTRIBUTES,
13370     ) -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
13371         self.inner.p_attributes = attributes;
13372         self
13373     }
dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoNVBuilder<'a>13374     pub fn dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
13375         self.inner.dw_access = dw_access;
13376         self
13377     }
13378     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13379     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13380     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryWin32HandleInfoNV13381     pub fn build(self) -> ExportMemoryWin32HandleInfoNV {
13382         self.inner
13383     }
13384 }
13385 #[repr(C)]
13386 #[derive(Copy, Clone, Debug)]
13387 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>"]
13388 pub struct Win32KeyedMutexAcquireReleaseInfoNV {
13389     pub s_type: StructureType,
13390     pub p_next: *const c_void,
13391     pub acquire_count: u32,
13392     pub p_acquire_syncs: *const DeviceMemory,
13393     pub p_acquire_keys: *const u64,
13394     pub p_acquire_timeout_milliseconds: *const u32,
13395     pub release_count: u32,
13396     pub p_release_syncs: *const DeviceMemory,
13397     pub p_release_keys: *const u64,
13398 }
13399 impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV {
default() -> Win32KeyedMutexAcquireReleaseInfoNV13400     fn default() -> Win32KeyedMutexAcquireReleaseInfoNV {
13401         Win32KeyedMutexAcquireReleaseInfoNV {
13402             s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
13403             p_next: ::std::ptr::null(),
13404             acquire_count: u32::default(),
13405             p_acquire_syncs: ::std::ptr::null(),
13406             p_acquire_keys: ::std::ptr::null(),
13407             p_acquire_timeout_milliseconds: ::std::ptr::null(),
13408             release_count: u32::default(),
13409             p_release_syncs: ::std::ptr::null(),
13410             p_release_keys: ::std::ptr::null(),
13411         }
13412     }
13413 }
13414 impl Win32KeyedMutexAcquireReleaseInfoNV {
builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>13415     pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13416         Win32KeyedMutexAcquireReleaseInfoNVBuilder {
13417             inner: Win32KeyedMutexAcquireReleaseInfoNV::default(),
13418             marker: ::std::marker::PhantomData,
13419         }
13420     }
13421 }
13422 #[repr(transparent)]
13423 pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13424     inner: Win32KeyedMutexAcquireReleaseInfoNV,
13425     marker: ::std::marker::PhantomData<&'a ()>,
13426 }
13427 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
13428 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {}
13429 impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13430     type Target = Win32KeyedMutexAcquireReleaseInfoNV;
deref(&self) -> &Self::Target13431     fn deref(&self) -> &Self::Target {
13432         &self.inner
13433     }
13434 }
13435 impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13436     fn deref_mut(&mut self) -> &mut Self::Target {
13437         &mut self.inner
13438     }
13439 }
13440 impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
acquire_syncs( mut self, acquire_syncs: &'a [DeviceMemory], ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>13441     pub fn acquire_syncs(
13442         mut self,
13443         acquire_syncs: &'a [DeviceMemory],
13444     ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13445         self.inner.acquire_count = acquire_syncs.len() as _;
13446         self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
13447         self
13448     }
acquire_keys( mut self, acquire_keys: &'a [u64], ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>13449     pub fn acquire_keys(
13450         mut self,
13451         acquire_keys: &'a [u64],
13452     ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13453         self.inner.acquire_count = acquire_keys.len() as _;
13454         self.inner.p_acquire_keys = acquire_keys.as_ptr();
13455         self
13456     }
acquire_timeout_milliseconds( mut self, acquire_timeout_milliseconds: &'a [u32], ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>13457     pub fn acquire_timeout_milliseconds(
13458         mut self,
13459         acquire_timeout_milliseconds: &'a [u32],
13460     ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13461         self.inner.acquire_count = acquire_timeout_milliseconds.len() as _;
13462         self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr();
13463         self
13464     }
release_syncs( mut self, release_syncs: &'a [DeviceMemory], ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>13465     pub fn release_syncs(
13466         mut self,
13467         release_syncs: &'a [DeviceMemory],
13468     ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13469         self.inner.release_count = release_syncs.len() as _;
13470         self.inner.p_release_syncs = release_syncs.as_ptr();
13471         self
13472     }
release_keys( mut self, release_keys: &'a [u64], ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>13473     pub fn release_keys(
13474         mut self,
13475         release_keys: &'a [u64],
13476     ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
13477         self.inner.release_count = release_keys.len() as _;
13478         self.inner.p_release_keys = release_keys.as_ptr();
13479         self
13480     }
13481     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13482     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13483     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Win32KeyedMutexAcquireReleaseInfoNV13484     pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV {
13485         self.inner
13486     }
13487 }
13488 #[repr(C)]
13489 #[derive(Copy, Clone, Debug)]
13490 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>"]
13491 pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13492     pub s_type: StructureType,
13493     pub p_next: *mut c_void,
13494     pub device_generated_commands: Bool32,
13495 }
13496 impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
default() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV13497     fn default() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13498         PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13499             s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
13500             p_next: ::std::ptr::null_mut(),
13501             device_generated_commands: Bool32::default(),
13502         }
13503     }
13504 }
13505 impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a>13506     pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13507         PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder {
13508             inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::default(),
13509             marker: ::std::marker::PhantomData,
13510         }
13511     }
13512 }
13513 #[repr(transparent)]
13514 pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13515     inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
13516     marker: ::std::marker::PhantomData<&'a ()>,
13517 }
13518 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {}
13519 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
13520 impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13521     type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
deref(&self) -> &Self::Target13522     fn deref(&self) -> &Self::Target {
13523         &self.inner
13524     }
13525 }
13526 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13527     fn deref_mut(&mut self) -> &mut Self::Target {
13528         &mut self.inner
13529     }
13530 }
13531 impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
device_generated_commands( mut self, device_generated_commands: bool, ) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a>13532     pub fn device_generated_commands(
13533         mut self,
13534         device_generated_commands: bool,
13535     ) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
13536         self.inner.device_generated_commands = device_generated_commands.into();
13537         self
13538     }
13539     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13540     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13541     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV13542     pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
13543         self.inner
13544     }
13545 }
13546 #[repr(C)]
13547 #[derive(Copy, Clone, Debug)]
13548 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevicePrivateDataCreateInfoEXT.html>"]
13549 pub struct DevicePrivateDataCreateInfoEXT {
13550     pub s_type: StructureType,
13551     pub p_next: *const c_void,
13552     pub private_data_slot_request_count: u32,
13553 }
13554 impl ::std::default::Default for DevicePrivateDataCreateInfoEXT {
default() -> DevicePrivateDataCreateInfoEXT13555     fn default() -> DevicePrivateDataCreateInfoEXT {
13556         DevicePrivateDataCreateInfoEXT {
13557             s_type: StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO_EXT,
13558             p_next: ::std::ptr::null(),
13559             private_data_slot_request_count: u32::default(),
13560         }
13561     }
13562 }
13563 impl DevicePrivateDataCreateInfoEXT {
builder<'a>() -> DevicePrivateDataCreateInfoEXTBuilder<'a>13564     pub fn builder<'a>() -> DevicePrivateDataCreateInfoEXTBuilder<'a> {
13565         DevicePrivateDataCreateInfoEXTBuilder {
13566             inner: DevicePrivateDataCreateInfoEXT::default(),
13567             marker: ::std::marker::PhantomData,
13568         }
13569     }
13570 }
13571 #[repr(transparent)]
13572 pub struct DevicePrivateDataCreateInfoEXTBuilder<'a> {
13573     inner: DevicePrivateDataCreateInfoEXT,
13574     marker: ::std::marker::PhantomData<&'a ()>,
13575 }
13576 unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoEXTBuilder<'_> {}
13577 unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoEXT {}
13578 impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoEXTBuilder<'a> {
13579     type Target = DevicePrivateDataCreateInfoEXT;
deref(&self) -> &Self::Target13580     fn deref(&self) -> &Self::Target {
13581         &self.inner
13582     }
13583 }
13584 impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13585     fn deref_mut(&mut self) -> &mut Self::Target {
13586         &mut self.inner
13587     }
13588 }
13589 impl<'a> DevicePrivateDataCreateInfoEXTBuilder<'a> {
private_data_slot_request_count( mut self, private_data_slot_request_count: u32, ) -> DevicePrivateDataCreateInfoEXTBuilder<'a>13590     pub fn private_data_slot_request_count(
13591         mut self,
13592         private_data_slot_request_count: u32,
13593     ) -> DevicePrivateDataCreateInfoEXTBuilder<'a> {
13594         self.inner.private_data_slot_request_count = private_data_slot_request_count;
13595         self
13596     }
13597     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13598     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13599     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DevicePrivateDataCreateInfoEXT13600     pub fn build(self) -> DevicePrivateDataCreateInfoEXT {
13601         self.inner
13602     }
13603 }
13604 #[repr(C)]
13605 #[derive(Copy, Clone, Debug)]
13606 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotCreateInfoEXT.html>"]
13607 pub struct PrivateDataSlotCreateInfoEXT {
13608     pub s_type: StructureType,
13609     pub p_next: *const c_void,
13610     pub flags: PrivateDataSlotCreateFlagsEXT,
13611 }
13612 impl ::std::default::Default for PrivateDataSlotCreateInfoEXT {
default() -> PrivateDataSlotCreateInfoEXT13613     fn default() -> PrivateDataSlotCreateInfoEXT {
13614         PrivateDataSlotCreateInfoEXT {
13615             s_type: StructureType::PRIVATE_DATA_SLOT_CREATE_INFO_EXT,
13616             p_next: ::std::ptr::null(),
13617             flags: PrivateDataSlotCreateFlagsEXT::default(),
13618         }
13619     }
13620 }
13621 impl PrivateDataSlotCreateInfoEXT {
builder<'a>() -> PrivateDataSlotCreateInfoEXTBuilder<'a>13622     pub fn builder<'a>() -> PrivateDataSlotCreateInfoEXTBuilder<'a> {
13623         PrivateDataSlotCreateInfoEXTBuilder {
13624             inner: PrivateDataSlotCreateInfoEXT::default(),
13625             marker: ::std::marker::PhantomData,
13626         }
13627     }
13628 }
13629 #[repr(transparent)]
13630 pub struct PrivateDataSlotCreateInfoEXTBuilder<'a> {
13631     inner: PrivateDataSlotCreateInfoEXT,
13632     marker: ::std::marker::PhantomData<&'a ()>,
13633 }
13634 pub unsafe trait ExtendsPrivateDataSlotCreateInfoEXT {}
13635 impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoEXTBuilder<'a> {
13636     type Target = PrivateDataSlotCreateInfoEXT;
deref(&self) -> &Self::Target13637     fn deref(&self) -> &Self::Target {
13638         &self.inner
13639     }
13640 }
13641 impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13642     fn deref_mut(&mut self) -> &mut Self::Target {
13643         &mut self.inner
13644     }
13645 }
13646 impl<'a> PrivateDataSlotCreateInfoEXTBuilder<'a> {
flags( mut self, flags: PrivateDataSlotCreateFlagsEXT, ) -> PrivateDataSlotCreateInfoEXTBuilder<'a>13647     pub fn flags(
13648         mut self,
13649         flags: PrivateDataSlotCreateFlagsEXT,
13650     ) -> PrivateDataSlotCreateInfoEXTBuilder<'a> {
13651         self.inner.flags = flags;
13652         self
13653     }
13654     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13655     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13656     #[doc = r" valid extension structs can be pushed into the chain."]
13657     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13658     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPrivateDataSlotCreateInfoEXT>( mut self, next: &'a mut T, ) -> PrivateDataSlotCreateInfoEXTBuilder<'a>13659     pub fn push_next<T: ExtendsPrivateDataSlotCreateInfoEXT>(
13660         mut self,
13661         next: &'a mut T,
13662     ) -> PrivateDataSlotCreateInfoEXTBuilder<'a> {
13663         unsafe {
13664             let next_ptr = next as *mut T as *mut BaseOutStructure;
13665             let last_next = ptr_chain_iter(next).last().unwrap();
13666             (*last_next).p_next = self.inner.p_next as _;
13667             self.inner.p_next = next_ptr as _;
13668         }
13669         self
13670     }
13671     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13672     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13673     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PrivateDataSlotCreateInfoEXT13674     pub fn build(self) -> PrivateDataSlotCreateInfoEXT {
13675         self.inner
13676     }
13677 }
13678 #[repr(C)]
13679 #[derive(Copy, Clone, Debug)]
13680 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePrivateDataFeaturesEXT.html>"]
13681 pub struct PhysicalDevicePrivateDataFeaturesEXT {
13682     pub s_type: StructureType,
13683     pub p_next: *mut c_void,
13684     pub private_data: Bool32,
13685 }
13686 impl ::std::default::Default for PhysicalDevicePrivateDataFeaturesEXT {
default() -> PhysicalDevicePrivateDataFeaturesEXT13687     fn default() -> PhysicalDevicePrivateDataFeaturesEXT {
13688         PhysicalDevicePrivateDataFeaturesEXT {
13689             s_type: StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT,
13690             p_next: ::std::ptr::null_mut(),
13691             private_data: Bool32::default(),
13692         }
13693     }
13694 }
13695 impl PhysicalDevicePrivateDataFeaturesEXT {
builder<'a>() -> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a>13696     pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
13697         PhysicalDevicePrivateDataFeaturesEXTBuilder {
13698             inner: PhysicalDevicePrivateDataFeaturesEXT::default(),
13699             marker: ::std::marker::PhantomData,
13700         }
13701     }
13702 }
13703 #[repr(transparent)]
13704 pub struct PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
13705     inner: PhysicalDevicePrivateDataFeaturesEXT,
13706     marker: ::std::marker::PhantomData<&'a ()>,
13707 }
13708 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXTBuilder<'_> {}
13709 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXT {}
13710 impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
13711     type Target = PhysicalDevicePrivateDataFeaturesEXT;
deref(&self) -> &Self::Target13712     fn deref(&self) -> &Self::Target {
13713         &self.inner
13714     }
13715 }
13716 impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13717     fn deref_mut(&mut self) -> &mut Self::Target {
13718         &mut self.inner
13719     }
13720 }
13721 impl<'a> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
private_data( mut self, private_data: bool, ) -> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a>13722     pub fn private_data(
13723         mut self,
13724         private_data: bool,
13725     ) -> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
13726         self.inner.private_data = private_data.into();
13727         self
13728     }
13729     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13730     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13731     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePrivateDataFeaturesEXT13732     pub fn build(self) -> PhysicalDevicePrivateDataFeaturesEXT {
13733         self.inner
13734     }
13735 }
13736 #[repr(C)]
13737 #[derive(Copy, Clone, Debug)]
13738 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>"]
13739 pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13740     pub s_type: StructureType,
13741     pub p_next: *mut c_void,
13742     pub max_graphics_shader_group_count: u32,
13743     pub max_indirect_sequence_count: u32,
13744     pub max_indirect_commands_token_count: u32,
13745     pub max_indirect_commands_stream_count: u32,
13746     pub max_indirect_commands_token_offset: u32,
13747     pub max_indirect_commands_stream_stride: u32,
13748     pub min_sequences_count_buffer_offset_alignment: u32,
13749     pub min_sequences_index_buffer_offset_alignment: u32,
13750     pub min_indirect_commands_buffer_offset_alignment: u32,
13751 }
13752 impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
default() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV13753     fn default() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13754         PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13755             s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
13756             p_next: ::std::ptr::null_mut(),
13757             max_graphics_shader_group_count: u32::default(),
13758             max_indirect_sequence_count: u32::default(),
13759             max_indirect_commands_token_count: u32::default(),
13760             max_indirect_commands_stream_count: u32::default(),
13761             max_indirect_commands_token_offset: u32::default(),
13762             max_indirect_commands_stream_stride: u32::default(),
13763             min_sequences_count_buffer_offset_alignment: u32::default(),
13764             min_sequences_index_buffer_offset_alignment: u32::default(),
13765             min_indirect_commands_buffer_offset_alignment: u32::default(),
13766         }
13767     }
13768 }
13769 impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13770     pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13771         PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder {
13772             inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::default(),
13773             marker: ::std::marker::PhantomData,
13774         }
13775     }
13776 }
13777 #[repr(transparent)]
13778 pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13779     inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
13780     marker: ::std::marker::PhantomData<&'a ()>,
13781 }
13782 unsafe impl ExtendsPhysicalDeviceProperties2
13783     for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_>
13784 {
13785 }
13786 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {}
13787 impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13788     type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
deref(&self) -> &Self::Target13789     fn deref(&self) -> &Self::Target {
13790         &self.inner
13791     }
13792 }
13793 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13794     fn deref_mut(&mut self) -> &mut Self::Target {
13795         &mut self.inner
13796     }
13797 }
13798 impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
max_graphics_shader_group_count( mut self, max_graphics_shader_group_count: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13799     pub fn max_graphics_shader_group_count(
13800         mut self,
13801         max_graphics_shader_group_count: u32,
13802     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13803         self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count;
13804         self
13805     }
max_indirect_sequence_count( mut self, max_indirect_sequence_count: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13806     pub fn max_indirect_sequence_count(
13807         mut self,
13808         max_indirect_sequence_count: u32,
13809     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13810         self.inner.max_indirect_sequence_count = max_indirect_sequence_count;
13811         self
13812     }
max_indirect_commands_token_count( mut self, max_indirect_commands_token_count: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13813     pub fn max_indirect_commands_token_count(
13814         mut self,
13815         max_indirect_commands_token_count: u32,
13816     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13817         self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count;
13818         self
13819     }
max_indirect_commands_stream_count( mut self, max_indirect_commands_stream_count: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13820     pub fn max_indirect_commands_stream_count(
13821         mut self,
13822         max_indirect_commands_stream_count: u32,
13823     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13824         self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count;
13825         self
13826     }
max_indirect_commands_token_offset( mut self, max_indirect_commands_token_offset: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13827     pub fn max_indirect_commands_token_offset(
13828         mut self,
13829         max_indirect_commands_token_offset: u32,
13830     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13831         self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset;
13832         self
13833     }
max_indirect_commands_stream_stride( mut self, max_indirect_commands_stream_stride: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13834     pub fn max_indirect_commands_stream_stride(
13835         mut self,
13836         max_indirect_commands_stream_stride: u32,
13837     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13838         self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride;
13839         self
13840     }
min_sequences_count_buffer_offset_alignment( mut self, min_sequences_count_buffer_offset_alignment: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13841     pub fn min_sequences_count_buffer_offset_alignment(
13842         mut self,
13843         min_sequences_count_buffer_offset_alignment: u32,
13844     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13845         self.inner.min_sequences_count_buffer_offset_alignment =
13846             min_sequences_count_buffer_offset_alignment;
13847         self
13848     }
min_sequences_index_buffer_offset_alignment( mut self, min_sequences_index_buffer_offset_alignment: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13849     pub fn min_sequences_index_buffer_offset_alignment(
13850         mut self,
13851         min_sequences_index_buffer_offset_alignment: u32,
13852     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13853         self.inner.min_sequences_index_buffer_offset_alignment =
13854             min_sequences_index_buffer_offset_alignment;
13855         self
13856     }
min_indirect_commands_buffer_offset_alignment( mut self, min_indirect_commands_buffer_offset_alignment: u32, ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>13857     pub fn min_indirect_commands_buffer_offset_alignment(
13858         mut self,
13859         min_indirect_commands_buffer_offset_alignment: u32,
13860     ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
13861         self.inner.min_indirect_commands_buffer_offset_alignment =
13862             min_indirect_commands_buffer_offset_alignment;
13863         self
13864     }
13865     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13866     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13867     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV13868     pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
13869         self.inner
13870     }
13871 }
13872 #[repr(C)]
13873 #[derive(Copy, Clone, Debug)]
13874 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html>"]
13875 pub struct GraphicsShaderGroupCreateInfoNV {
13876     pub s_type: StructureType,
13877     pub p_next: *const c_void,
13878     pub stage_count: u32,
13879     pub p_stages: *const PipelineShaderStageCreateInfo,
13880     pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
13881     pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
13882 }
13883 impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV {
default() -> GraphicsShaderGroupCreateInfoNV13884     fn default() -> GraphicsShaderGroupCreateInfoNV {
13885         GraphicsShaderGroupCreateInfoNV {
13886             s_type: StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
13887             p_next: ::std::ptr::null(),
13888             stage_count: u32::default(),
13889             p_stages: ::std::ptr::null(),
13890             p_vertex_input_state: ::std::ptr::null(),
13891             p_tessellation_state: ::std::ptr::null(),
13892         }
13893     }
13894 }
13895 impl GraphicsShaderGroupCreateInfoNV {
builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a>13896     pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
13897         GraphicsShaderGroupCreateInfoNVBuilder {
13898             inner: GraphicsShaderGroupCreateInfoNV::default(),
13899             marker: ::std::marker::PhantomData,
13900         }
13901     }
13902 }
13903 #[repr(transparent)]
13904 pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> {
13905     inner: GraphicsShaderGroupCreateInfoNV,
13906     marker: ::std::marker::PhantomData<&'a ()>,
13907 }
13908 pub unsafe trait ExtendsGraphicsShaderGroupCreateInfoNV {}
13909 impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
13910     type Target = GraphicsShaderGroupCreateInfoNV;
deref(&self) -> &Self::Target13911     fn deref(&self) -> &Self::Target {
13912         &self.inner
13913     }
13914 }
13915 impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target13916     fn deref_mut(&mut self) -> &mut Self::Target {
13917         &mut self.inner
13918     }
13919 }
13920 impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
stages( mut self, stages: &'a [PipelineShaderStageCreateInfo], ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a>13921     pub fn stages(
13922         mut self,
13923         stages: &'a [PipelineShaderStageCreateInfo],
13924     ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
13925         self.inner.stage_count = stages.len() as _;
13926         self.inner.p_stages = stages.as_ptr();
13927         self
13928     }
vertex_input_state( mut self, vertex_input_state: &'a PipelineVertexInputStateCreateInfo, ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a>13929     pub fn vertex_input_state(
13930         mut self,
13931         vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
13932     ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
13933         self.inner.p_vertex_input_state = vertex_input_state;
13934         self
13935     }
tessellation_state( mut self, tessellation_state: &'a PipelineTessellationStateCreateInfo, ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a>13936     pub fn tessellation_state(
13937         mut self,
13938         tessellation_state: &'a PipelineTessellationStateCreateInfo,
13939     ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
13940         self.inner.p_tessellation_state = tessellation_state;
13941         self
13942     }
13943     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
13944     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
13945     #[doc = r" valid extension structs can be pushed into the chain."]
13946     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
13947     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGraphicsShaderGroupCreateInfoNV>( mut self, next: &'a mut T, ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a>13948     pub fn push_next<T: ExtendsGraphicsShaderGroupCreateInfoNV>(
13949         mut self,
13950         next: &'a mut T,
13951     ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
13952         unsafe {
13953             let next_ptr = next as *mut T as *mut BaseOutStructure;
13954             let last_next = ptr_chain_iter(next).last().unwrap();
13955             (*last_next).p_next = self.inner.p_next as _;
13956             self.inner.p_next = next_ptr as _;
13957         }
13958         self
13959     }
13960     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
13961     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
13962     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GraphicsShaderGroupCreateInfoNV13963     pub fn build(self) -> GraphicsShaderGroupCreateInfoNV {
13964         self.inner
13965     }
13966 }
13967 #[repr(C)]
13968 #[derive(Copy, Clone, Debug)]
13969 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>"]
13970 pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
13971     pub s_type: StructureType,
13972     pub p_next: *const c_void,
13973     pub group_count: u32,
13974     pub p_groups: *const GraphicsShaderGroupCreateInfoNV,
13975     pub pipeline_count: u32,
13976     pub p_pipelines: *const Pipeline,
13977 }
13978 impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV {
default() -> GraphicsPipelineShaderGroupsCreateInfoNV13979     fn default() -> GraphicsPipelineShaderGroupsCreateInfoNV {
13980         GraphicsPipelineShaderGroupsCreateInfoNV {
13981             s_type: StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
13982             p_next: ::std::ptr::null(),
13983             group_count: u32::default(),
13984             p_groups: ::std::ptr::null(),
13985             pipeline_count: u32::default(),
13986             p_pipelines: ::std::ptr::null(),
13987         }
13988     }
13989 }
13990 impl GraphicsPipelineShaderGroupsCreateInfoNV {
builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a>13991     pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
13992         GraphicsPipelineShaderGroupsCreateInfoNVBuilder {
13993             inner: GraphicsPipelineShaderGroupsCreateInfoNV::default(),
13994             marker: ::std::marker::PhantomData,
13995         }
13996     }
13997 }
13998 #[repr(transparent)]
13999 pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14000     inner: GraphicsPipelineShaderGroupsCreateInfoNV,
14001     marker: ::std::marker::PhantomData<&'a ()>,
14002 }
14003 unsafe impl ExtendsGraphicsPipelineCreateInfo
14004     for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_>
14005 {
14006 }
14007 unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {}
14008 impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14009     type Target = GraphicsPipelineShaderGroupsCreateInfoNV;
deref(&self) -> &Self::Target14010     fn deref(&self) -> &Self::Target {
14011         &self.inner
14012     }
14013 }
14014 impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14015     fn deref_mut(&mut self) -> &mut Self::Target {
14016         &mut self.inner
14017     }
14018 }
14019 impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
groups( mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV], ) -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a>14020     pub fn groups(
14021         mut self,
14022         groups: &'a [GraphicsShaderGroupCreateInfoNV],
14023     ) -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14024         self.inner.group_count = groups.len() as _;
14025         self.inner.p_groups = groups.as_ptr();
14026         self
14027     }
pipelines( mut self, pipelines: &'a [Pipeline], ) -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a>14028     pub fn pipelines(
14029         mut self,
14030         pipelines: &'a [Pipeline],
14031     ) -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
14032         self.inner.pipeline_count = pipelines.len() as _;
14033         self.inner.p_pipelines = pipelines.as_ptr();
14034         self
14035     }
14036     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14037     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14038     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV14039     pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV {
14040         self.inner
14041     }
14042 }
14043 #[repr(C)]
14044 #[derive(Copy, Clone, Default, Debug)]
14045 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html>"]
14046 pub struct BindShaderGroupIndirectCommandNV {
14047     pub group_index: u32,
14048 }
14049 impl BindShaderGroupIndirectCommandNV {
builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a>14050     pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
14051         BindShaderGroupIndirectCommandNVBuilder {
14052             inner: BindShaderGroupIndirectCommandNV::default(),
14053             marker: ::std::marker::PhantomData,
14054         }
14055     }
14056 }
14057 #[repr(transparent)]
14058 pub struct BindShaderGroupIndirectCommandNVBuilder<'a> {
14059     inner: BindShaderGroupIndirectCommandNV,
14060     marker: ::std::marker::PhantomData<&'a ()>,
14061 }
14062 impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> {
14063     type Target = BindShaderGroupIndirectCommandNV;
deref(&self) -> &Self::Target14064     fn deref(&self) -> &Self::Target {
14065         &self.inner
14066     }
14067 }
14068 impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14069     fn deref_mut(&mut self) -> &mut Self::Target {
14070         &mut self.inner
14071     }
14072 }
14073 impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
group_index(mut self, group_index: u32) -> BindShaderGroupIndirectCommandNVBuilder<'a>14074     pub fn group_index(mut self, group_index: u32) -> BindShaderGroupIndirectCommandNVBuilder<'a> {
14075         self.inner.group_index = group_index;
14076         self
14077     }
14078     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14079     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14080     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindShaderGroupIndirectCommandNV14081     pub fn build(self) -> BindShaderGroupIndirectCommandNV {
14082         self.inner
14083     }
14084 }
14085 #[repr(C)]
14086 #[derive(Copy, Clone, Default, Debug)]
14087 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html>"]
14088 pub struct BindIndexBufferIndirectCommandNV {
14089     pub buffer_address: DeviceAddress,
14090     pub size: u32,
14091     pub index_type: IndexType,
14092 }
14093 impl BindIndexBufferIndirectCommandNV {
builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a>14094     pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
14095         BindIndexBufferIndirectCommandNVBuilder {
14096             inner: BindIndexBufferIndirectCommandNV::default(),
14097             marker: ::std::marker::PhantomData,
14098         }
14099     }
14100 }
14101 #[repr(transparent)]
14102 pub struct BindIndexBufferIndirectCommandNVBuilder<'a> {
14103     inner: BindIndexBufferIndirectCommandNV,
14104     marker: ::std::marker::PhantomData<&'a ()>,
14105 }
14106 impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> {
14107     type Target = BindIndexBufferIndirectCommandNV;
deref(&self) -> &Self::Target14108     fn deref(&self) -> &Self::Target {
14109         &self.inner
14110     }
14111 }
14112 impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14113     fn deref_mut(&mut self) -> &mut Self::Target {
14114         &mut self.inner
14115     }
14116 }
14117 impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
buffer_address( mut self, buffer_address: DeviceAddress, ) -> BindIndexBufferIndirectCommandNVBuilder<'a>14118     pub fn buffer_address(
14119         mut self,
14120         buffer_address: DeviceAddress,
14121     ) -> BindIndexBufferIndirectCommandNVBuilder<'a> {
14122         self.inner.buffer_address = buffer_address;
14123         self
14124     }
size(mut self, size: u32) -> BindIndexBufferIndirectCommandNVBuilder<'a>14125     pub fn size(mut self, size: u32) -> BindIndexBufferIndirectCommandNVBuilder<'a> {
14126         self.inner.size = size;
14127         self
14128     }
index_type( mut self, index_type: IndexType, ) -> BindIndexBufferIndirectCommandNVBuilder<'a>14129     pub fn index_type(
14130         mut self,
14131         index_type: IndexType,
14132     ) -> BindIndexBufferIndirectCommandNVBuilder<'a> {
14133         self.inner.index_type = index_type;
14134         self
14135     }
14136     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14137     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14138     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindIndexBufferIndirectCommandNV14139     pub fn build(self) -> BindIndexBufferIndirectCommandNV {
14140         self.inner
14141     }
14142 }
14143 #[repr(C)]
14144 #[derive(Copy, Clone, Default, Debug)]
14145 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html>"]
14146 pub struct BindVertexBufferIndirectCommandNV {
14147     pub buffer_address: DeviceAddress,
14148     pub size: u32,
14149     pub stride: u32,
14150 }
14151 impl BindVertexBufferIndirectCommandNV {
builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a>14152     pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
14153         BindVertexBufferIndirectCommandNVBuilder {
14154             inner: BindVertexBufferIndirectCommandNV::default(),
14155             marker: ::std::marker::PhantomData,
14156         }
14157     }
14158 }
14159 #[repr(transparent)]
14160 pub struct BindVertexBufferIndirectCommandNVBuilder<'a> {
14161     inner: BindVertexBufferIndirectCommandNV,
14162     marker: ::std::marker::PhantomData<&'a ()>,
14163 }
14164 impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> {
14165     type Target = BindVertexBufferIndirectCommandNV;
deref(&self) -> &Self::Target14166     fn deref(&self) -> &Self::Target {
14167         &self.inner
14168     }
14169 }
14170 impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14171     fn deref_mut(&mut self) -> &mut Self::Target {
14172         &mut self.inner
14173     }
14174 }
14175 impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
buffer_address( mut self, buffer_address: DeviceAddress, ) -> BindVertexBufferIndirectCommandNVBuilder<'a>14176     pub fn buffer_address(
14177         mut self,
14178         buffer_address: DeviceAddress,
14179     ) -> BindVertexBufferIndirectCommandNVBuilder<'a> {
14180         self.inner.buffer_address = buffer_address;
14181         self
14182     }
size(mut self, size: u32) -> BindVertexBufferIndirectCommandNVBuilder<'a>14183     pub fn size(mut self, size: u32) -> BindVertexBufferIndirectCommandNVBuilder<'a> {
14184         self.inner.size = size;
14185         self
14186     }
stride(mut self, stride: u32) -> BindVertexBufferIndirectCommandNVBuilder<'a>14187     pub fn stride(mut self, stride: u32) -> BindVertexBufferIndirectCommandNVBuilder<'a> {
14188         self.inner.stride = stride;
14189         self
14190     }
14191     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14192     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14193     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindVertexBufferIndirectCommandNV14194     pub fn build(self) -> BindVertexBufferIndirectCommandNV {
14195         self.inner
14196     }
14197 }
14198 #[repr(C)]
14199 #[derive(Copy, Clone, Default, Debug)]
14200 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html>"]
14201 pub struct SetStateFlagsIndirectCommandNV {
14202     pub data: u32,
14203 }
14204 impl SetStateFlagsIndirectCommandNV {
builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a>14205     pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
14206         SetStateFlagsIndirectCommandNVBuilder {
14207             inner: SetStateFlagsIndirectCommandNV::default(),
14208             marker: ::std::marker::PhantomData,
14209         }
14210     }
14211 }
14212 #[repr(transparent)]
14213 pub struct SetStateFlagsIndirectCommandNVBuilder<'a> {
14214     inner: SetStateFlagsIndirectCommandNV,
14215     marker: ::std::marker::PhantomData<&'a ()>,
14216 }
14217 impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> {
14218     type Target = SetStateFlagsIndirectCommandNV;
deref(&self) -> &Self::Target14219     fn deref(&self) -> &Self::Target {
14220         &self.inner
14221     }
14222 }
14223 impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14224     fn deref_mut(&mut self) -> &mut Self::Target {
14225         &mut self.inner
14226     }
14227 }
14228 impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
data(mut self, data: u32) -> SetStateFlagsIndirectCommandNVBuilder<'a>14229     pub fn data(mut self, data: u32) -> SetStateFlagsIndirectCommandNVBuilder<'a> {
14230         self.inner.data = data;
14231         self
14232     }
14233     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14234     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14235     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SetStateFlagsIndirectCommandNV14236     pub fn build(self) -> SetStateFlagsIndirectCommandNV {
14237         self.inner
14238     }
14239 }
14240 #[repr(C)]
14241 #[derive(Copy, Clone, Default, Debug)]
14242 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsStreamNV.html>"]
14243 pub struct IndirectCommandsStreamNV {
14244     pub buffer: Buffer,
14245     pub offset: DeviceSize,
14246 }
14247 impl IndirectCommandsStreamNV {
builder<'a>() -> IndirectCommandsStreamNVBuilder<'a>14248     pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> {
14249         IndirectCommandsStreamNVBuilder {
14250             inner: IndirectCommandsStreamNV::default(),
14251             marker: ::std::marker::PhantomData,
14252         }
14253     }
14254 }
14255 #[repr(transparent)]
14256 pub struct IndirectCommandsStreamNVBuilder<'a> {
14257     inner: IndirectCommandsStreamNV,
14258     marker: ::std::marker::PhantomData<&'a ()>,
14259 }
14260 impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> {
14261     type Target = IndirectCommandsStreamNV;
deref(&self) -> &Self::Target14262     fn deref(&self) -> &Self::Target {
14263         &self.inner
14264     }
14265 }
14266 impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14267     fn deref_mut(&mut self) -> &mut Self::Target {
14268         &mut self.inner
14269     }
14270 }
14271 impl<'a> IndirectCommandsStreamNVBuilder<'a> {
buffer(mut self, buffer: Buffer) -> IndirectCommandsStreamNVBuilder<'a>14272     pub fn buffer(mut self, buffer: Buffer) -> IndirectCommandsStreamNVBuilder<'a> {
14273         self.inner.buffer = buffer;
14274         self
14275     }
offset(mut self, offset: DeviceSize) -> IndirectCommandsStreamNVBuilder<'a>14276     pub fn offset(mut self, offset: DeviceSize) -> IndirectCommandsStreamNVBuilder<'a> {
14277         self.inner.offset = offset;
14278         self
14279     }
14280     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14281     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14282     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IndirectCommandsStreamNV14283     pub fn build(self) -> IndirectCommandsStreamNV {
14284         self.inner
14285     }
14286 }
14287 #[repr(C)]
14288 #[derive(Copy, Clone, Debug)]
14289 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html>"]
14290 pub struct IndirectCommandsLayoutTokenNV {
14291     pub s_type: StructureType,
14292     pub p_next: *const c_void,
14293     pub token_type: IndirectCommandsTokenTypeNV,
14294     pub stream: u32,
14295     pub offset: u32,
14296     pub vertex_binding_unit: u32,
14297     pub vertex_dynamic_stride: Bool32,
14298     pub pushconstant_pipeline_layout: PipelineLayout,
14299     pub pushconstant_shader_stage_flags: ShaderStageFlags,
14300     pub pushconstant_offset: u32,
14301     pub pushconstant_size: u32,
14302     pub indirect_state_flags: IndirectStateFlagsNV,
14303     pub index_type_count: u32,
14304     pub p_index_types: *const IndexType,
14305     pub p_index_type_values: *const u32,
14306 }
14307 impl ::std::default::Default for IndirectCommandsLayoutTokenNV {
default() -> IndirectCommandsLayoutTokenNV14308     fn default() -> IndirectCommandsLayoutTokenNV {
14309         IndirectCommandsLayoutTokenNV {
14310             s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
14311             p_next: ::std::ptr::null(),
14312             token_type: IndirectCommandsTokenTypeNV::default(),
14313             stream: u32::default(),
14314             offset: u32::default(),
14315             vertex_binding_unit: u32::default(),
14316             vertex_dynamic_stride: Bool32::default(),
14317             pushconstant_pipeline_layout: PipelineLayout::default(),
14318             pushconstant_shader_stage_flags: ShaderStageFlags::default(),
14319             pushconstant_offset: u32::default(),
14320             pushconstant_size: u32::default(),
14321             indirect_state_flags: IndirectStateFlagsNV::default(),
14322             index_type_count: u32::default(),
14323             p_index_types: ::std::ptr::null(),
14324             p_index_type_values: ::std::ptr::null(),
14325         }
14326     }
14327 }
14328 impl IndirectCommandsLayoutTokenNV {
builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a>14329     pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14330         IndirectCommandsLayoutTokenNVBuilder {
14331             inner: IndirectCommandsLayoutTokenNV::default(),
14332             marker: ::std::marker::PhantomData,
14333         }
14334     }
14335 }
14336 #[repr(transparent)]
14337 pub struct IndirectCommandsLayoutTokenNVBuilder<'a> {
14338     inner: IndirectCommandsLayoutTokenNV,
14339     marker: ::std::marker::PhantomData<&'a ()>,
14340 }
14341 pub unsafe trait ExtendsIndirectCommandsLayoutTokenNV {}
14342 impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
14343     type Target = IndirectCommandsLayoutTokenNV;
deref(&self) -> &Self::Target14344     fn deref(&self) -> &Self::Target {
14345         &self.inner
14346     }
14347 }
14348 impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14349     fn deref_mut(&mut self) -> &mut Self::Target {
14350         &mut self.inner
14351     }
14352 }
14353 impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
token_type( mut self, token_type: IndirectCommandsTokenTypeNV, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14354     pub fn token_type(
14355         mut self,
14356         token_type: IndirectCommandsTokenTypeNV,
14357     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14358         self.inner.token_type = token_type;
14359         self
14360     }
stream(mut self, stream: u32) -> IndirectCommandsLayoutTokenNVBuilder<'a>14361     pub fn stream(mut self, stream: u32) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14362         self.inner.stream = stream;
14363         self
14364     }
offset(mut self, offset: u32) -> IndirectCommandsLayoutTokenNVBuilder<'a>14365     pub fn offset(mut self, offset: u32) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14366         self.inner.offset = offset;
14367         self
14368     }
vertex_binding_unit( mut self, vertex_binding_unit: u32, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14369     pub fn vertex_binding_unit(
14370         mut self,
14371         vertex_binding_unit: u32,
14372     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14373         self.inner.vertex_binding_unit = vertex_binding_unit;
14374         self
14375     }
vertex_dynamic_stride( mut self, vertex_dynamic_stride: bool, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14376     pub fn vertex_dynamic_stride(
14377         mut self,
14378         vertex_dynamic_stride: bool,
14379     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14380         self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into();
14381         self
14382     }
pushconstant_pipeline_layout( mut self, pushconstant_pipeline_layout: PipelineLayout, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14383     pub fn pushconstant_pipeline_layout(
14384         mut self,
14385         pushconstant_pipeline_layout: PipelineLayout,
14386     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14387         self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout;
14388         self
14389     }
pushconstant_shader_stage_flags( mut self, pushconstant_shader_stage_flags: ShaderStageFlags, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14390     pub fn pushconstant_shader_stage_flags(
14391         mut self,
14392         pushconstant_shader_stage_flags: ShaderStageFlags,
14393     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14394         self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags;
14395         self
14396     }
pushconstant_offset( mut self, pushconstant_offset: u32, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14397     pub fn pushconstant_offset(
14398         mut self,
14399         pushconstant_offset: u32,
14400     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14401         self.inner.pushconstant_offset = pushconstant_offset;
14402         self
14403     }
pushconstant_size( mut self, pushconstant_size: u32, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14404     pub fn pushconstant_size(
14405         mut self,
14406         pushconstant_size: u32,
14407     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14408         self.inner.pushconstant_size = pushconstant_size;
14409         self
14410     }
indirect_state_flags( mut self, indirect_state_flags: IndirectStateFlagsNV, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14411     pub fn indirect_state_flags(
14412         mut self,
14413         indirect_state_flags: IndirectStateFlagsNV,
14414     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14415         self.inner.indirect_state_flags = indirect_state_flags;
14416         self
14417     }
index_types( mut self, index_types: &'a [IndexType], ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14418     pub fn index_types(
14419         mut self,
14420         index_types: &'a [IndexType],
14421     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14422         self.inner.index_type_count = index_types.len() as _;
14423         self.inner.p_index_types = index_types.as_ptr();
14424         self
14425     }
index_type_values( mut self, index_type_values: &'a [u32], ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14426     pub fn index_type_values(
14427         mut self,
14428         index_type_values: &'a [u32],
14429     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14430         self.inner.index_type_count = index_type_values.len() as _;
14431         self.inner.p_index_type_values = index_type_values.as_ptr();
14432         self
14433     }
14434     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14435     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14436     #[doc = r" valid extension structs can be pushed into the chain."]
14437     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14438     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsIndirectCommandsLayoutTokenNV>( mut self, next: &'a mut T, ) -> IndirectCommandsLayoutTokenNVBuilder<'a>14439     pub fn push_next<T: ExtendsIndirectCommandsLayoutTokenNV>(
14440         mut self,
14441         next: &'a mut T,
14442     ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
14443         unsafe {
14444             let next_ptr = next as *mut T as *mut BaseOutStructure;
14445             let last_next = ptr_chain_iter(next).last().unwrap();
14446             (*last_next).p_next = self.inner.p_next as _;
14447             self.inner.p_next = next_ptr as _;
14448         }
14449         self
14450     }
14451     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14452     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14453     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IndirectCommandsLayoutTokenNV14454     pub fn build(self) -> IndirectCommandsLayoutTokenNV {
14455         self.inner
14456     }
14457 }
14458 #[repr(C)]
14459 #[derive(Copy, Clone, Debug)]
14460 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>"]
14461 pub struct IndirectCommandsLayoutCreateInfoNV {
14462     pub s_type: StructureType,
14463     pub p_next: *const c_void,
14464     pub flags: IndirectCommandsLayoutUsageFlagsNV,
14465     pub pipeline_bind_point: PipelineBindPoint,
14466     pub token_count: u32,
14467     pub p_tokens: *const IndirectCommandsLayoutTokenNV,
14468     pub stream_count: u32,
14469     pub p_stream_strides: *const u32,
14470 }
14471 impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV {
default() -> IndirectCommandsLayoutCreateInfoNV14472     fn default() -> IndirectCommandsLayoutCreateInfoNV {
14473         IndirectCommandsLayoutCreateInfoNV {
14474             s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
14475             p_next: ::std::ptr::null(),
14476             flags: IndirectCommandsLayoutUsageFlagsNV::default(),
14477             pipeline_bind_point: PipelineBindPoint::default(),
14478             token_count: u32::default(),
14479             p_tokens: ::std::ptr::null(),
14480             stream_count: u32::default(),
14481             p_stream_strides: ::std::ptr::null(),
14482         }
14483     }
14484 }
14485 impl IndirectCommandsLayoutCreateInfoNV {
builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a>14486     pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14487         IndirectCommandsLayoutCreateInfoNVBuilder {
14488             inner: IndirectCommandsLayoutCreateInfoNV::default(),
14489             marker: ::std::marker::PhantomData,
14490         }
14491     }
14492 }
14493 #[repr(transparent)]
14494 pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14495     inner: IndirectCommandsLayoutCreateInfoNV,
14496     marker: ::std::marker::PhantomData<&'a ()>,
14497 }
14498 pub unsafe trait ExtendsIndirectCommandsLayoutCreateInfoNV {}
14499 impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14500     type Target = IndirectCommandsLayoutCreateInfoNV;
deref(&self) -> &Self::Target14501     fn deref(&self) -> &Self::Target {
14502         &self.inner
14503     }
14504 }
14505 impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14506     fn deref_mut(&mut self) -> &mut Self::Target {
14507         &mut self.inner
14508     }
14509 }
14510 impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
flags( mut self, flags: IndirectCommandsLayoutUsageFlagsNV, ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a>14511     pub fn flags(
14512         mut self,
14513         flags: IndirectCommandsLayoutUsageFlagsNV,
14514     ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14515         self.inner.flags = flags;
14516         self
14517     }
pipeline_bind_point( mut self, pipeline_bind_point: PipelineBindPoint, ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a>14518     pub fn pipeline_bind_point(
14519         mut self,
14520         pipeline_bind_point: PipelineBindPoint,
14521     ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14522         self.inner.pipeline_bind_point = pipeline_bind_point;
14523         self
14524     }
tokens( mut self, tokens: &'a [IndirectCommandsLayoutTokenNV], ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a>14525     pub fn tokens(
14526         mut self,
14527         tokens: &'a [IndirectCommandsLayoutTokenNV],
14528     ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14529         self.inner.token_count = tokens.len() as _;
14530         self.inner.p_tokens = tokens.as_ptr();
14531         self
14532     }
stream_strides( mut self, stream_strides: &'a [u32], ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a>14533     pub fn stream_strides(
14534         mut self,
14535         stream_strides: &'a [u32],
14536     ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14537         self.inner.stream_count = stream_strides.len() as _;
14538         self.inner.p_stream_strides = stream_strides.as_ptr();
14539         self
14540     }
14541     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14542     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14543     #[doc = r" valid extension structs can be pushed into the chain."]
14544     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14545     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsIndirectCommandsLayoutCreateInfoNV>( mut self, next: &'a mut T, ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a>14546     pub fn push_next<T: ExtendsIndirectCommandsLayoutCreateInfoNV>(
14547         mut self,
14548         next: &'a mut T,
14549     ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
14550         unsafe {
14551             let next_ptr = next as *mut T as *mut BaseOutStructure;
14552             let last_next = ptr_chain_iter(next).last().unwrap();
14553             (*last_next).p_next = self.inner.p_next as _;
14554             self.inner.p_next = next_ptr as _;
14555         }
14556         self
14557     }
14558     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14559     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14560     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IndirectCommandsLayoutCreateInfoNV14561     pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV {
14562         self.inner
14563     }
14564 }
14565 #[repr(C)]
14566 #[derive(Copy, Clone, Debug)]
14567 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsInfoNV.html>"]
14568 pub struct GeneratedCommandsInfoNV {
14569     pub s_type: StructureType,
14570     pub p_next: *const c_void,
14571     pub pipeline_bind_point: PipelineBindPoint,
14572     pub pipeline: Pipeline,
14573     pub indirect_commands_layout: IndirectCommandsLayoutNV,
14574     pub stream_count: u32,
14575     pub p_streams: *const IndirectCommandsStreamNV,
14576     pub sequences_count: u32,
14577     pub preprocess_buffer: Buffer,
14578     pub preprocess_offset: DeviceSize,
14579     pub preprocess_size: DeviceSize,
14580     pub sequences_count_buffer: Buffer,
14581     pub sequences_count_offset: DeviceSize,
14582     pub sequences_index_buffer: Buffer,
14583     pub sequences_index_offset: DeviceSize,
14584 }
14585 impl ::std::default::Default for GeneratedCommandsInfoNV {
default() -> GeneratedCommandsInfoNV14586     fn default() -> GeneratedCommandsInfoNV {
14587         GeneratedCommandsInfoNV {
14588             s_type: StructureType::GENERATED_COMMANDS_INFO_NV,
14589             p_next: ::std::ptr::null(),
14590             pipeline_bind_point: PipelineBindPoint::default(),
14591             pipeline: Pipeline::default(),
14592             indirect_commands_layout: IndirectCommandsLayoutNV::default(),
14593             stream_count: u32::default(),
14594             p_streams: ::std::ptr::null(),
14595             sequences_count: u32::default(),
14596             preprocess_buffer: Buffer::default(),
14597             preprocess_offset: DeviceSize::default(),
14598             preprocess_size: DeviceSize::default(),
14599             sequences_count_buffer: Buffer::default(),
14600             sequences_count_offset: DeviceSize::default(),
14601             sequences_index_buffer: Buffer::default(),
14602             sequences_index_offset: DeviceSize::default(),
14603         }
14604     }
14605 }
14606 impl GeneratedCommandsInfoNV {
builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a>14607     pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> {
14608         GeneratedCommandsInfoNVBuilder {
14609             inner: GeneratedCommandsInfoNV::default(),
14610             marker: ::std::marker::PhantomData,
14611         }
14612     }
14613 }
14614 #[repr(transparent)]
14615 pub struct GeneratedCommandsInfoNVBuilder<'a> {
14616     inner: GeneratedCommandsInfoNV,
14617     marker: ::std::marker::PhantomData<&'a ()>,
14618 }
14619 pub unsafe trait ExtendsGeneratedCommandsInfoNV {}
14620 impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> {
14621     type Target = GeneratedCommandsInfoNV;
deref(&self) -> &Self::Target14622     fn deref(&self) -> &Self::Target {
14623         &self.inner
14624     }
14625 }
14626 impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14627     fn deref_mut(&mut self) -> &mut Self::Target {
14628         &mut self.inner
14629     }
14630 }
14631 impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
pipeline_bind_point( mut self, pipeline_bind_point: PipelineBindPoint, ) -> GeneratedCommandsInfoNVBuilder<'a>14632     pub fn pipeline_bind_point(
14633         mut self,
14634         pipeline_bind_point: PipelineBindPoint,
14635     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14636         self.inner.pipeline_bind_point = pipeline_bind_point;
14637         self
14638     }
pipeline(mut self, pipeline: Pipeline) -> GeneratedCommandsInfoNVBuilder<'a>14639     pub fn pipeline(mut self, pipeline: Pipeline) -> GeneratedCommandsInfoNVBuilder<'a> {
14640         self.inner.pipeline = pipeline;
14641         self
14642     }
indirect_commands_layout( mut self, indirect_commands_layout: IndirectCommandsLayoutNV, ) -> GeneratedCommandsInfoNVBuilder<'a>14643     pub fn indirect_commands_layout(
14644         mut self,
14645         indirect_commands_layout: IndirectCommandsLayoutNV,
14646     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14647         self.inner.indirect_commands_layout = indirect_commands_layout;
14648         self
14649     }
streams( mut self, streams: &'a [IndirectCommandsStreamNV], ) -> GeneratedCommandsInfoNVBuilder<'a>14650     pub fn streams(
14651         mut self,
14652         streams: &'a [IndirectCommandsStreamNV],
14653     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14654         self.inner.stream_count = streams.len() as _;
14655         self.inner.p_streams = streams.as_ptr();
14656         self
14657     }
sequences_count(mut self, sequences_count: u32) -> GeneratedCommandsInfoNVBuilder<'a>14658     pub fn sequences_count(mut self, sequences_count: u32) -> GeneratedCommandsInfoNVBuilder<'a> {
14659         self.inner.sequences_count = sequences_count;
14660         self
14661     }
preprocess_buffer( mut self, preprocess_buffer: Buffer, ) -> GeneratedCommandsInfoNVBuilder<'a>14662     pub fn preprocess_buffer(
14663         mut self,
14664         preprocess_buffer: Buffer,
14665     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14666         self.inner.preprocess_buffer = preprocess_buffer;
14667         self
14668     }
preprocess_offset( mut self, preprocess_offset: DeviceSize, ) -> GeneratedCommandsInfoNVBuilder<'a>14669     pub fn preprocess_offset(
14670         mut self,
14671         preprocess_offset: DeviceSize,
14672     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14673         self.inner.preprocess_offset = preprocess_offset;
14674         self
14675     }
preprocess_size( mut self, preprocess_size: DeviceSize, ) -> GeneratedCommandsInfoNVBuilder<'a>14676     pub fn preprocess_size(
14677         mut self,
14678         preprocess_size: DeviceSize,
14679     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14680         self.inner.preprocess_size = preprocess_size;
14681         self
14682     }
sequences_count_buffer( mut self, sequences_count_buffer: Buffer, ) -> GeneratedCommandsInfoNVBuilder<'a>14683     pub fn sequences_count_buffer(
14684         mut self,
14685         sequences_count_buffer: Buffer,
14686     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14687         self.inner.sequences_count_buffer = sequences_count_buffer;
14688         self
14689     }
sequences_count_offset( mut self, sequences_count_offset: DeviceSize, ) -> GeneratedCommandsInfoNVBuilder<'a>14690     pub fn sequences_count_offset(
14691         mut self,
14692         sequences_count_offset: DeviceSize,
14693     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14694         self.inner.sequences_count_offset = sequences_count_offset;
14695         self
14696     }
sequences_index_buffer( mut self, sequences_index_buffer: Buffer, ) -> GeneratedCommandsInfoNVBuilder<'a>14697     pub fn sequences_index_buffer(
14698         mut self,
14699         sequences_index_buffer: Buffer,
14700     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14701         self.inner.sequences_index_buffer = sequences_index_buffer;
14702         self
14703     }
sequences_index_offset( mut self, sequences_index_offset: DeviceSize, ) -> GeneratedCommandsInfoNVBuilder<'a>14704     pub fn sequences_index_offset(
14705         mut self,
14706         sequences_index_offset: DeviceSize,
14707     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14708         self.inner.sequences_index_offset = sequences_index_offset;
14709         self
14710     }
14711     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14712     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14713     #[doc = r" valid extension structs can be pushed into the chain."]
14714     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14715     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGeneratedCommandsInfoNV>( mut self, next: &'a mut T, ) -> GeneratedCommandsInfoNVBuilder<'a>14716     pub fn push_next<T: ExtendsGeneratedCommandsInfoNV>(
14717         mut self,
14718         next: &'a mut T,
14719     ) -> GeneratedCommandsInfoNVBuilder<'a> {
14720         unsafe {
14721             let next_ptr = next as *mut T as *mut BaseOutStructure;
14722             let last_next = ptr_chain_iter(next).last().unwrap();
14723             (*last_next).p_next = self.inner.p_next as _;
14724             self.inner.p_next = next_ptr as _;
14725         }
14726         self
14727     }
14728     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14729     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14730     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeneratedCommandsInfoNV14731     pub fn build(self) -> GeneratedCommandsInfoNV {
14732         self.inner
14733     }
14734 }
14735 #[repr(C)]
14736 #[derive(Copy, Clone, Debug)]
14737 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>"]
14738 pub struct GeneratedCommandsMemoryRequirementsInfoNV {
14739     pub s_type: StructureType,
14740     pub p_next: *const c_void,
14741     pub pipeline_bind_point: PipelineBindPoint,
14742     pub pipeline: Pipeline,
14743     pub indirect_commands_layout: IndirectCommandsLayoutNV,
14744     pub max_sequences_count: u32,
14745 }
14746 impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV {
default() -> GeneratedCommandsMemoryRequirementsInfoNV14747     fn default() -> GeneratedCommandsMemoryRequirementsInfoNV {
14748         GeneratedCommandsMemoryRequirementsInfoNV {
14749             s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
14750             p_next: ::std::ptr::null(),
14751             pipeline_bind_point: PipelineBindPoint::default(),
14752             pipeline: Pipeline::default(),
14753             indirect_commands_layout: IndirectCommandsLayoutNV::default(),
14754             max_sequences_count: u32::default(),
14755         }
14756     }
14757 }
14758 impl GeneratedCommandsMemoryRequirementsInfoNV {
builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>14759     pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14760         GeneratedCommandsMemoryRequirementsInfoNVBuilder {
14761             inner: GeneratedCommandsMemoryRequirementsInfoNV::default(),
14762             marker: ::std::marker::PhantomData,
14763         }
14764     }
14765 }
14766 #[repr(transparent)]
14767 pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14768     inner: GeneratedCommandsMemoryRequirementsInfoNV,
14769     marker: ::std::marker::PhantomData<&'a ()>,
14770 }
14771 pub unsafe trait ExtendsGeneratedCommandsMemoryRequirementsInfoNV {}
14772 impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14773     type Target = GeneratedCommandsMemoryRequirementsInfoNV;
deref(&self) -> &Self::Target14774     fn deref(&self) -> &Self::Target {
14775         &self.inner
14776     }
14777 }
14778 impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target14779     fn deref_mut(&mut self) -> &mut Self::Target {
14780         &mut self.inner
14781     }
14782 }
14783 impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
pipeline_bind_point( mut self, pipeline_bind_point: PipelineBindPoint, ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>14784     pub fn pipeline_bind_point(
14785         mut self,
14786         pipeline_bind_point: PipelineBindPoint,
14787     ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14788         self.inner.pipeline_bind_point = pipeline_bind_point;
14789         self
14790     }
pipeline( mut self, pipeline: Pipeline, ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>14791     pub fn pipeline(
14792         mut self,
14793         pipeline: Pipeline,
14794     ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14795         self.inner.pipeline = pipeline;
14796         self
14797     }
indirect_commands_layout( mut self, indirect_commands_layout: IndirectCommandsLayoutNV, ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>14798     pub fn indirect_commands_layout(
14799         mut self,
14800         indirect_commands_layout: IndirectCommandsLayoutNV,
14801     ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14802         self.inner.indirect_commands_layout = indirect_commands_layout;
14803         self
14804     }
max_sequences_count( mut self, max_sequences_count: u32, ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>14805     pub fn max_sequences_count(
14806         mut self,
14807         max_sequences_count: u32,
14808     ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14809         self.inner.max_sequences_count = max_sequences_count;
14810         self
14811     }
14812     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14813     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14814     #[doc = r" valid extension structs can be pushed into the chain."]
14815     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14816     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGeneratedCommandsMemoryRequirementsInfoNV>( mut self, next: &'a mut T, ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>14817     pub fn push_next<T: ExtendsGeneratedCommandsMemoryRequirementsInfoNV>(
14818         mut self,
14819         next: &'a mut T,
14820     ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
14821         unsafe {
14822             let next_ptr = next as *mut T as *mut BaseOutStructure;
14823             let last_next = ptr_chain_iter(next).last().unwrap();
14824             (*last_next).p_next = self.inner.p_next as _;
14825             self.inner.p_next = next_ptr as _;
14826         }
14827         self
14828     }
14829     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14830     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14831     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeneratedCommandsMemoryRequirementsInfoNV14832     pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV {
14833         self.inner
14834     }
14835 }
14836 #[repr(C)]
14837 #[derive(Copy, Clone, Debug)]
14838 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures2.html>"]
14839 pub struct PhysicalDeviceFeatures2 {
14840     pub s_type: StructureType,
14841     pub p_next: *mut c_void,
14842     pub features: PhysicalDeviceFeatures,
14843 }
14844 impl ::std::default::Default for PhysicalDeviceFeatures2 {
default() -> PhysicalDeviceFeatures214845     fn default() -> PhysicalDeviceFeatures2 {
14846         PhysicalDeviceFeatures2 {
14847             s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2,
14848             p_next: ::std::ptr::null_mut(),
14849             features: PhysicalDeviceFeatures::default(),
14850         }
14851     }
14852 }
14853 impl PhysicalDeviceFeatures2 {
builder<'a>() -> PhysicalDeviceFeatures2Builder<'a>14854     pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> {
14855         PhysicalDeviceFeatures2Builder {
14856             inner: PhysicalDeviceFeatures2::default(),
14857             marker: ::std::marker::PhantomData,
14858         }
14859     }
14860 }
14861 #[repr(transparent)]
14862 pub struct PhysicalDeviceFeatures2Builder<'a> {
14863     inner: PhysicalDeviceFeatures2,
14864     marker: ::std::marker::PhantomData<&'a ()>,
14865 }
14866 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {}
14867 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {}
14868 impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> {
14869     type Target = PhysicalDeviceFeatures2;
deref(&self) -> &Self::Target14870     fn deref(&self) -> &Self::Target {
14871         &self.inner
14872     }
14873 }
14874 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target14875     fn deref_mut(&mut self) -> &mut Self::Target {
14876         &mut self.inner
14877     }
14878 }
14879 impl<'a> PhysicalDeviceFeatures2Builder<'a> {
features( mut self, features: PhysicalDeviceFeatures, ) -> PhysicalDeviceFeatures2Builder<'a>14880     pub fn features(
14881         mut self,
14882         features: PhysicalDeviceFeatures,
14883     ) -> PhysicalDeviceFeatures2Builder<'a> {
14884         self.inner.features = features;
14885         self
14886     }
14887     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14888     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14889     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFeatures214890     pub fn build(self) -> PhysicalDeviceFeatures2 {
14891         self.inner
14892     }
14893 }
14894 #[repr(C)]
14895 #[derive(Copy, Clone, Debug)]
14896 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties2.html>"]
14897 pub struct PhysicalDeviceProperties2 {
14898     pub s_type: StructureType,
14899     pub p_next: *mut c_void,
14900     pub properties: PhysicalDeviceProperties,
14901 }
14902 impl ::std::default::Default for PhysicalDeviceProperties2 {
default() -> PhysicalDeviceProperties214903     fn default() -> PhysicalDeviceProperties2 {
14904         PhysicalDeviceProperties2 {
14905             s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2,
14906             p_next: ::std::ptr::null_mut(),
14907             properties: PhysicalDeviceProperties::default(),
14908         }
14909     }
14910 }
14911 impl PhysicalDeviceProperties2 {
builder<'a>() -> PhysicalDeviceProperties2Builder<'a>14912     pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> {
14913         PhysicalDeviceProperties2Builder {
14914             inner: PhysicalDeviceProperties2::default(),
14915             marker: ::std::marker::PhantomData,
14916         }
14917     }
14918 }
14919 #[repr(transparent)]
14920 pub struct PhysicalDeviceProperties2Builder<'a> {
14921     inner: PhysicalDeviceProperties2,
14922     marker: ::std::marker::PhantomData<&'a ()>,
14923 }
14924 pub unsafe trait ExtendsPhysicalDeviceProperties2 {}
14925 impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> {
14926     type Target = PhysicalDeviceProperties2;
deref(&self) -> &Self::Target14927     fn deref(&self) -> &Self::Target {
14928         &self.inner
14929     }
14930 }
14931 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target14932     fn deref_mut(&mut self) -> &mut Self::Target {
14933         &mut self.inner
14934     }
14935 }
14936 impl<'a> PhysicalDeviceProperties2Builder<'a> {
properties( mut self, properties: PhysicalDeviceProperties, ) -> PhysicalDeviceProperties2Builder<'a>14937     pub fn properties(
14938         mut self,
14939         properties: PhysicalDeviceProperties,
14940     ) -> PhysicalDeviceProperties2Builder<'a> {
14941         self.inner.properties = properties;
14942         self
14943     }
14944     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
14945     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
14946     #[doc = r" valid extension structs can be pushed into the chain."]
14947     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
14948     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceProperties2>( mut self, next: &'a mut T, ) -> PhysicalDeviceProperties2Builder<'a>14949     pub fn push_next<T: ExtendsPhysicalDeviceProperties2>(
14950         mut self,
14951         next: &'a mut T,
14952     ) -> PhysicalDeviceProperties2Builder<'a> {
14953         unsafe {
14954             let next_ptr = next as *mut T as *mut BaseOutStructure;
14955             let last_next = ptr_chain_iter(next).last().unwrap();
14956             (*last_next).p_next = self.inner.p_next as _;
14957             self.inner.p_next = next_ptr as _;
14958         }
14959         self
14960     }
14961     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
14962     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
14963     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProperties214964     pub fn build(self) -> PhysicalDeviceProperties2 {
14965         self.inner
14966     }
14967 }
14968 #[repr(C)]
14969 #[derive(Copy, Clone, Debug)]
14970 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatProperties2.html>"]
14971 pub struct FormatProperties2 {
14972     pub s_type: StructureType,
14973     pub p_next: *mut c_void,
14974     pub format_properties: FormatProperties,
14975 }
14976 impl ::std::default::Default for FormatProperties2 {
default() -> FormatProperties214977     fn default() -> FormatProperties2 {
14978         FormatProperties2 {
14979             s_type: StructureType::FORMAT_PROPERTIES_2,
14980             p_next: ::std::ptr::null_mut(),
14981             format_properties: FormatProperties::default(),
14982         }
14983     }
14984 }
14985 impl FormatProperties2 {
builder<'a>() -> FormatProperties2Builder<'a>14986     pub fn builder<'a>() -> FormatProperties2Builder<'a> {
14987         FormatProperties2Builder {
14988             inner: FormatProperties2::default(),
14989             marker: ::std::marker::PhantomData,
14990         }
14991     }
14992 }
14993 #[repr(transparent)]
14994 pub struct FormatProperties2Builder<'a> {
14995     inner: FormatProperties2,
14996     marker: ::std::marker::PhantomData<&'a ()>,
14997 }
14998 pub unsafe trait ExtendsFormatProperties2 {}
14999 impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> {
15000     type Target = FormatProperties2;
deref(&self) -> &Self::Target15001     fn deref(&self) -> &Self::Target {
15002         &self.inner
15003     }
15004 }
15005 impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15006     fn deref_mut(&mut self) -> &mut Self::Target {
15007         &mut self.inner
15008     }
15009 }
15010 impl<'a> FormatProperties2Builder<'a> {
format_properties( mut self, format_properties: FormatProperties, ) -> FormatProperties2Builder<'a>15011     pub fn format_properties(
15012         mut self,
15013         format_properties: FormatProperties,
15014     ) -> FormatProperties2Builder<'a> {
15015         self.inner.format_properties = format_properties;
15016         self
15017     }
15018     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15019     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15020     #[doc = r" valid extension structs can be pushed into the chain."]
15021     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15022     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFormatProperties2>( mut self, next: &'a mut T, ) -> FormatProperties2Builder<'a>15023     pub fn push_next<T: ExtendsFormatProperties2>(
15024         mut self,
15025         next: &'a mut T,
15026     ) -> FormatProperties2Builder<'a> {
15027         unsafe {
15028             let next_ptr = next as *mut T as *mut BaseOutStructure;
15029             let last_next = ptr_chain_iter(next).last().unwrap();
15030             (*last_next).p_next = self.inner.p_next as _;
15031             self.inner.p_next = next_ptr as _;
15032         }
15033         self
15034     }
15035     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15036     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15037     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FormatProperties215038     pub fn build(self) -> FormatProperties2 {
15039         self.inner
15040     }
15041 }
15042 #[repr(C)]
15043 #[derive(Copy, Clone, Debug)]
15044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatProperties2.html>"]
15045 pub struct ImageFormatProperties2 {
15046     pub s_type: StructureType,
15047     pub p_next: *mut c_void,
15048     pub image_format_properties: ImageFormatProperties,
15049 }
15050 impl ::std::default::Default for ImageFormatProperties2 {
default() -> ImageFormatProperties215051     fn default() -> ImageFormatProperties2 {
15052         ImageFormatProperties2 {
15053             s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2,
15054             p_next: ::std::ptr::null_mut(),
15055             image_format_properties: ImageFormatProperties::default(),
15056         }
15057     }
15058 }
15059 impl ImageFormatProperties2 {
builder<'a>() -> ImageFormatProperties2Builder<'a>15060     pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> {
15061         ImageFormatProperties2Builder {
15062             inner: ImageFormatProperties2::default(),
15063             marker: ::std::marker::PhantomData,
15064         }
15065     }
15066 }
15067 #[repr(transparent)]
15068 pub struct ImageFormatProperties2Builder<'a> {
15069     inner: ImageFormatProperties2,
15070     marker: ::std::marker::PhantomData<&'a ()>,
15071 }
15072 pub unsafe trait ExtendsImageFormatProperties2 {}
15073 impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> {
15074     type Target = ImageFormatProperties2;
deref(&self) -> &Self::Target15075     fn deref(&self) -> &Self::Target {
15076         &self.inner
15077     }
15078 }
15079 impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15080     fn deref_mut(&mut self) -> &mut Self::Target {
15081         &mut self.inner
15082     }
15083 }
15084 impl<'a> ImageFormatProperties2Builder<'a> {
image_format_properties( mut self, image_format_properties: ImageFormatProperties, ) -> ImageFormatProperties2Builder<'a>15085     pub fn image_format_properties(
15086         mut self,
15087         image_format_properties: ImageFormatProperties,
15088     ) -> ImageFormatProperties2Builder<'a> {
15089         self.inner.image_format_properties = image_format_properties;
15090         self
15091     }
15092     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15093     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15094     #[doc = r" valid extension structs can be pushed into the chain."]
15095     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15096     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageFormatProperties2>( mut self, next: &'a mut T, ) -> ImageFormatProperties2Builder<'a>15097     pub fn push_next<T: ExtendsImageFormatProperties2>(
15098         mut self,
15099         next: &'a mut T,
15100     ) -> ImageFormatProperties2Builder<'a> {
15101         unsafe {
15102             let next_ptr = next as *mut T as *mut BaseOutStructure;
15103             let last_next = ptr_chain_iter(next).last().unwrap();
15104             (*last_next).p_next = self.inner.p_next as _;
15105             self.inner.p_next = next_ptr as _;
15106         }
15107         self
15108     }
15109     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15110     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15111     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageFormatProperties215112     pub fn build(self) -> ImageFormatProperties2 {
15113         self.inner
15114     }
15115 }
15116 #[repr(C)]
15117 #[derive(Copy, Clone, Debug)]
15118 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html>"]
15119 pub struct PhysicalDeviceImageFormatInfo2 {
15120     pub s_type: StructureType,
15121     pub p_next: *const c_void,
15122     pub format: Format,
15123     pub ty: ImageType,
15124     pub tiling: ImageTiling,
15125     pub usage: ImageUsageFlags,
15126     pub flags: ImageCreateFlags,
15127 }
15128 impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 {
default() -> PhysicalDeviceImageFormatInfo215129     fn default() -> PhysicalDeviceImageFormatInfo2 {
15130         PhysicalDeviceImageFormatInfo2 {
15131             s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
15132             p_next: ::std::ptr::null(),
15133             format: Format::default(),
15134             ty: ImageType::default(),
15135             tiling: ImageTiling::default(),
15136             usage: ImageUsageFlags::default(),
15137             flags: ImageCreateFlags::default(),
15138         }
15139     }
15140 }
15141 impl PhysicalDeviceImageFormatInfo2 {
builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a>15142     pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15143         PhysicalDeviceImageFormatInfo2Builder {
15144             inner: PhysicalDeviceImageFormatInfo2::default(),
15145             marker: ::std::marker::PhantomData,
15146         }
15147     }
15148 }
15149 #[repr(transparent)]
15150 pub struct PhysicalDeviceImageFormatInfo2Builder<'a> {
15151     inner: PhysicalDeviceImageFormatInfo2,
15152     marker: ::std::marker::PhantomData<&'a ()>,
15153 }
15154 pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {}
15155 impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> {
15156     type Target = PhysicalDeviceImageFormatInfo2;
deref(&self) -> &Self::Target15157     fn deref(&self) -> &Self::Target {
15158         &self.inner
15159     }
15160 }
15161 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15162     fn deref_mut(&mut self) -> &mut Self::Target {
15163         &mut self.inner
15164     }
15165 }
15166 impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
format(mut self, format: Format) -> PhysicalDeviceImageFormatInfo2Builder<'a>15167     pub fn format(mut self, format: Format) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15168         self.inner.format = format;
15169         self
15170     }
ty(mut self, ty: ImageType) -> PhysicalDeviceImageFormatInfo2Builder<'a>15171     pub fn ty(mut self, ty: ImageType) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15172         self.inner.ty = ty;
15173         self
15174     }
tiling(mut self, tiling: ImageTiling) -> PhysicalDeviceImageFormatInfo2Builder<'a>15175     pub fn tiling(mut self, tiling: ImageTiling) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15176         self.inner.tiling = tiling;
15177         self
15178     }
usage(mut self, usage: ImageUsageFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a>15179     pub fn usage(mut self, usage: ImageUsageFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15180         self.inner.usage = usage;
15181         self
15182     }
flags(mut self, flags: ImageCreateFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a>15183     pub fn flags(mut self, flags: ImageCreateFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15184         self.inner.flags = flags;
15185         self
15186     }
15187     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15188     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15189     #[doc = r" valid extension structs can be pushed into the chain."]
15190     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15191     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>( mut self, next: &'a mut T, ) -> PhysicalDeviceImageFormatInfo2Builder<'a>15192     pub fn push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(
15193         mut self,
15194         next: &'a mut T,
15195     ) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
15196         unsafe {
15197             let next_ptr = next as *mut T as *mut BaseOutStructure;
15198             let last_next = ptr_chain_iter(next).last().unwrap();
15199             (*last_next).p_next = self.inner.p_next as _;
15200             self.inner.p_next = next_ptr as _;
15201         }
15202         self
15203     }
15204     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15205     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15206     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageFormatInfo215207     pub fn build(self) -> PhysicalDeviceImageFormatInfo2 {
15208         self.inner
15209     }
15210 }
15211 #[repr(C)]
15212 #[derive(Copy, Clone, Debug)]
15213 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyProperties2.html>"]
15214 pub struct QueueFamilyProperties2 {
15215     pub s_type: StructureType,
15216     pub p_next: *mut c_void,
15217     pub queue_family_properties: QueueFamilyProperties,
15218 }
15219 impl ::std::default::Default for QueueFamilyProperties2 {
default() -> QueueFamilyProperties215220     fn default() -> QueueFamilyProperties2 {
15221         QueueFamilyProperties2 {
15222             s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2,
15223             p_next: ::std::ptr::null_mut(),
15224             queue_family_properties: QueueFamilyProperties::default(),
15225         }
15226     }
15227 }
15228 impl QueueFamilyProperties2 {
builder<'a>() -> QueueFamilyProperties2Builder<'a>15229     pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> {
15230         QueueFamilyProperties2Builder {
15231             inner: QueueFamilyProperties2::default(),
15232             marker: ::std::marker::PhantomData,
15233         }
15234     }
15235 }
15236 #[repr(transparent)]
15237 pub struct QueueFamilyProperties2Builder<'a> {
15238     inner: QueueFamilyProperties2,
15239     marker: ::std::marker::PhantomData<&'a ()>,
15240 }
15241 pub unsafe trait ExtendsQueueFamilyProperties2 {}
15242 impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> {
15243     type Target = QueueFamilyProperties2;
deref(&self) -> &Self::Target15244     fn deref(&self) -> &Self::Target {
15245         &self.inner
15246     }
15247 }
15248 impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15249     fn deref_mut(&mut self) -> &mut Self::Target {
15250         &mut self.inner
15251     }
15252 }
15253 impl<'a> QueueFamilyProperties2Builder<'a> {
queue_family_properties( mut self, queue_family_properties: QueueFamilyProperties, ) -> QueueFamilyProperties2Builder<'a>15254     pub fn queue_family_properties(
15255         mut self,
15256         queue_family_properties: QueueFamilyProperties,
15257     ) -> QueueFamilyProperties2Builder<'a> {
15258         self.inner.queue_family_properties = queue_family_properties;
15259         self
15260     }
15261     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15262     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15263     #[doc = r" valid extension structs can be pushed into the chain."]
15264     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15265     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsQueueFamilyProperties2>( mut self, next: &'a mut T, ) -> QueueFamilyProperties2Builder<'a>15266     pub fn push_next<T: ExtendsQueueFamilyProperties2>(
15267         mut self,
15268         next: &'a mut T,
15269     ) -> QueueFamilyProperties2Builder<'a> {
15270         unsafe {
15271             let next_ptr = next as *mut T as *mut BaseOutStructure;
15272             let last_next = ptr_chain_iter(next).last().unwrap();
15273             (*last_next).p_next = self.inner.p_next as _;
15274             self.inner.p_next = next_ptr as _;
15275         }
15276         self
15277     }
15278     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15279     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15280     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyProperties215281     pub fn build(self) -> QueueFamilyProperties2 {
15282         self.inner
15283     }
15284 }
15285 #[repr(C)]
15286 #[derive(Copy, Clone, Debug)]
15287 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html>"]
15288 pub struct PhysicalDeviceMemoryProperties2 {
15289     pub s_type: StructureType,
15290     pub p_next: *mut c_void,
15291     pub memory_properties: PhysicalDeviceMemoryProperties,
15292 }
15293 impl ::std::default::Default for PhysicalDeviceMemoryProperties2 {
default() -> PhysicalDeviceMemoryProperties215294     fn default() -> PhysicalDeviceMemoryProperties2 {
15295         PhysicalDeviceMemoryProperties2 {
15296             s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
15297             p_next: ::std::ptr::null_mut(),
15298             memory_properties: PhysicalDeviceMemoryProperties::default(),
15299         }
15300     }
15301 }
15302 impl PhysicalDeviceMemoryProperties2 {
builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a>15303     pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> {
15304         PhysicalDeviceMemoryProperties2Builder {
15305             inner: PhysicalDeviceMemoryProperties2::default(),
15306             marker: ::std::marker::PhantomData,
15307         }
15308     }
15309 }
15310 #[repr(transparent)]
15311 pub struct PhysicalDeviceMemoryProperties2Builder<'a> {
15312     inner: PhysicalDeviceMemoryProperties2,
15313     marker: ::std::marker::PhantomData<&'a ()>,
15314 }
15315 pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {}
15316 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> {
15317     type Target = PhysicalDeviceMemoryProperties2;
deref(&self) -> &Self::Target15318     fn deref(&self) -> &Self::Target {
15319         &self.inner
15320     }
15321 }
15322 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15323     fn deref_mut(&mut self) -> &mut Self::Target {
15324         &mut self.inner
15325     }
15326 }
15327 impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
memory_properties( mut self, memory_properties: PhysicalDeviceMemoryProperties, ) -> PhysicalDeviceMemoryProperties2Builder<'a>15328     pub fn memory_properties(
15329         mut self,
15330         memory_properties: PhysicalDeviceMemoryProperties,
15331     ) -> PhysicalDeviceMemoryProperties2Builder<'a> {
15332         self.inner.memory_properties = memory_properties;
15333         self
15334     }
15335     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15336     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15337     #[doc = r" valid extension structs can be pushed into the chain."]
15338     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15339     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceMemoryProperties2>( mut self, next: &'a mut T, ) -> PhysicalDeviceMemoryProperties2Builder<'a>15340     pub fn push_next<T: ExtendsPhysicalDeviceMemoryProperties2>(
15341         mut self,
15342         next: &'a mut T,
15343     ) -> PhysicalDeviceMemoryProperties2Builder<'a> {
15344         unsafe {
15345             let next_ptr = next as *mut T as *mut BaseOutStructure;
15346             let last_next = ptr_chain_iter(next).last().unwrap();
15347             (*last_next).p_next = self.inner.p_next as _;
15348             self.inner.p_next = next_ptr as _;
15349         }
15350         self
15351     }
15352     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15353     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15354     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryProperties215355     pub fn build(self) -> PhysicalDeviceMemoryProperties2 {
15356         self.inner
15357     }
15358 }
15359 #[repr(C)]
15360 #[derive(Copy, Clone, Debug)]
15361 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatProperties2.html>"]
15362 pub struct SparseImageFormatProperties2 {
15363     pub s_type: StructureType,
15364     pub p_next: *mut c_void,
15365     pub properties: SparseImageFormatProperties,
15366 }
15367 impl ::std::default::Default for SparseImageFormatProperties2 {
default() -> SparseImageFormatProperties215368     fn default() -> SparseImageFormatProperties2 {
15369         SparseImageFormatProperties2 {
15370             s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2,
15371             p_next: ::std::ptr::null_mut(),
15372             properties: SparseImageFormatProperties::default(),
15373         }
15374     }
15375 }
15376 impl SparseImageFormatProperties2 {
builder<'a>() -> SparseImageFormatProperties2Builder<'a>15377     pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> {
15378         SparseImageFormatProperties2Builder {
15379             inner: SparseImageFormatProperties2::default(),
15380             marker: ::std::marker::PhantomData,
15381         }
15382     }
15383 }
15384 #[repr(transparent)]
15385 pub struct SparseImageFormatProperties2Builder<'a> {
15386     inner: SparseImageFormatProperties2,
15387     marker: ::std::marker::PhantomData<&'a ()>,
15388 }
15389 pub unsafe trait ExtendsSparseImageFormatProperties2 {}
15390 impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> {
15391     type Target = SparseImageFormatProperties2;
deref(&self) -> &Self::Target15392     fn deref(&self) -> &Self::Target {
15393         &self.inner
15394     }
15395 }
15396 impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15397     fn deref_mut(&mut self) -> &mut Self::Target {
15398         &mut self.inner
15399     }
15400 }
15401 impl<'a> SparseImageFormatProperties2Builder<'a> {
properties( mut self, properties: SparseImageFormatProperties, ) -> SparseImageFormatProperties2Builder<'a>15402     pub fn properties(
15403         mut self,
15404         properties: SparseImageFormatProperties,
15405     ) -> SparseImageFormatProperties2Builder<'a> {
15406         self.inner.properties = properties;
15407         self
15408     }
15409     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15410     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15411     #[doc = r" valid extension structs can be pushed into the chain."]
15412     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15413     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSparseImageFormatProperties2>( mut self, next: &'a mut T, ) -> SparseImageFormatProperties2Builder<'a>15414     pub fn push_next<T: ExtendsSparseImageFormatProperties2>(
15415         mut self,
15416         next: &'a mut T,
15417     ) -> SparseImageFormatProperties2Builder<'a> {
15418         unsafe {
15419             let next_ptr = next as *mut T as *mut BaseOutStructure;
15420             let last_next = ptr_chain_iter(next).last().unwrap();
15421             (*last_next).p_next = self.inner.p_next as _;
15422             self.inner.p_next = next_ptr as _;
15423         }
15424         self
15425     }
15426     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15427     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15428     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageFormatProperties215429     pub fn build(self) -> SparseImageFormatProperties2 {
15430         self.inner
15431     }
15432 }
15433 #[repr(C)]
15434 #[derive(Copy, Clone, Debug)]
15435 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>"]
15436 pub struct PhysicalDeviceSparseImageFormatInfo2 {
15437     pub s_type: StructureType,
15438     pub p_next: *const c_void,
15439     pub format: Format,
15440     pub ty: ImageType,
15441     pub samples: SampleCountFlags,
15442     pub usage: ImageUsageFlags,
15443     pub tiling: ImageTiling,
15444 }
15445 impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 {
default() -> PhysicalDeviceSparseImageFormatInfo215446     fn default() -> PhysicalDeviceSparseImageFormatInfo2 {
15447         PhysicalDeviceSparseImageFormatInfo2 {
15448             s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
15449             p_next: ::std::ptr::null(),
15450             format: Format::default(),
15451             ty: ImageType::default(),
15452             samples: SampleCountFlags::default(),
15453             usage: ImageUsageFlags::default(),
15454             tiling: ImageTiling::default(),
15455         }
15456     }
15457 }
15458 impl PhysicalDeviceSparseImageFormatInfo2 {
builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15459     pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15460         PhysicalDeviceSparseImageFormatInfo2Builder {
15461             inner: PhysicalDeviceSparseImageFormatInfo2::default(),
15462             marker: ::std::marker::PhantomData,
15463         }
15464     }
15465 }
15466 #[repr(transparent)]
15467 pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15468     inner: PhysicalDeviceSparseImageFormatInfo2,
15469     marker: ::std::marker::PhantomData<&'a ()>,
15470 }
15471 pub unsafe trait ExtendsPhysicalDeviceSparseImageFormatInfo2 {}
15472 impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15473     type Target = PhysicalDeviceSparseImageFormatInfo2;
deref(&self) -> &Self::Target15474     fn deref(&self) -> &Self::Target {
15475         &self.inner
15476     }
15477 }
15478 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target15479     fn deref_mut(&mut self) -> &mut Self::Target {
15480         &mut self.inner
15481     }
15482 }
15483 impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
format(mut self, format: Format) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15484     pub fn format(mut self, format: Format) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15485         self.inner.format = format;
15486         self
15487     }
ty(mut self, ty: ImageType) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15488     pub fn ty(mut self, ty: ImageType) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15489         self.inner.ty = ty;
15490         self
15491     }
samples( mut self, samples: SampleCountFlags, ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15492     pub fn samples(
15493         mut self,
15494         samples: SampleCountFlags,
15495     ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15496         self.inner.samples = samples;
15497         self
15498     }
usage( mut self, usage: ImageUsageFlags, ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15499     pub fn usage(
15500         mut self,
15501         usage: ImageUsageFlags,
15502     ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15503         self.inner.usage = usage;
15504         self
15505     }
tiling( mut self, tiling: ImageTiling, ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15506     pub fn tiling(
15507         mut self,
15508         tiling: ImageTiling,
15509     ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15510         self.inner.tiling = tiling;
15511         self
15512     }
15513     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
15514     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
15515     #[doc = r" valid extension structs can be pushed into the chain."]
15516     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
15517     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceSparseImageFormatInfo2>( mut self, next: &'a mut T, ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a>15518     pub fn push_next<T: ExtendsPhysicalDeviceSparseImageFormatInfo2>(
15519         mut self,
15520         next: &'a mut T,
15521     ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
15522         unsafe {
15523             let next_ptr = next as *mut T as *mut BaseOutStructure;
15524             let last_next = ptr_chain_iter(next).last().unwrap();
15525             (*last_next).p_next = self.inner.p_next as _;
15526             self.inner.p_next = next_ptr as _;
15527         }
15528         self
15529     }
15530     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15531     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15532     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSparseImageFormatInfo215533     pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 {
15534         self.inner
15535     }
15536 }
15537 #[repr(C)]
15538 #[derive(Copy, Clone, Debug)]
15539 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>"]
15540 pub struct PhysicalDevicePushDescriptorPropertiesKHR {
15541     pub s_type: StructureType,
15542     pub p_next: *mut c_void,
15543     pub max_push_descriptors: u32,
15544 }
15545 impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR {
default() -> PhysicalDevicePushDescriptorPropertiesKHR15546     fn default() -> PhysicalDevicePushDescriptorPropertiesKHR {
15547         PhysicalDevicePushDescriptorPropertiesKHR {
15548             s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
15549             p_next: ::std::ptr::null_mut(),
15550             max_push_descriptors: u32::default(),
15551         }
15552     }
15553 }
15554 impl PhysicalDevicePushDescriptorPropertiesKHR {
builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a>15555     pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15556         PhysicalDevicePushDescriptorPropertiesKHRBuilder {
15557             inner: PhysicalDevicePushDescriptorPropertiesKHR::default(),
15558             marker: ::std::marker::PhantomData,
15559         }
15560     }
15561 }
15562 #[repr(transparent)]
15563 pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15564     inner: PhysicalDevicePushDescriptorPropertiesKHR,
15565     marker: ::std::marker::PhantomData<&'a ()>,
15566 }
15567 unsafe impl ExtendsPhysicalDeviceProperties2
15568     for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_>
15569 {
15570 }
15571 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {}
15572 impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15573     type Target = PhysicalDevicePushDescriptorPropertiesKHR;
deref(&self) -> &Self::Target15574     fn deref(&self) -> &Self::Target {
15575         &self.inner
15576     }
15577 }
15578 impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15579     fn deref_mut(&mut self) -> &mut Self::Target {
15580         &mut self.inner
15581     }
15582 }
15583 impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
max_push_descriptors( mut self, max_push_descriptors: u32, ) -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a>15584     pub fn max_push_descriptors(
15585         mut self,
15586         max_push_descriptors: u32,
15587     ) -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
15588         self.inner.max_push_descriptors = max_push_descriptors;
15589         self
15590     }
15591     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15592     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15593     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePushDescriptorPropertiesKHR15594     pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR {
15595         self.inner
15596     }
15597 }
15598 #[repr(C)]
15599 #[derive(Copy, Clone, Default, Debug)]
15600 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConformanceVersion.html>"]
15601 pub struct ConformanceVersion {
15602     pub major: u8,
15603     pub minor: u8,
15604     pub subminor: u8,
15605     pub patch: u8,
15606 }
15607 impl ConformanceVersion {
builder<'a>() -> ConformanceVersionBuilder<'a>15608     pub fn builder<'a>() -> ConformanceVersionBuilder<'a> {
15609         ConformanceVersionBuilder {
15610             inner: ConformanceVersion::default(),
15611             marker: ::std::marker::PhantomData,
15612         }
15613     }
15614 }
15615 #[repr(transparent)]
15616 pub struct ConformanceVersionBuilder<'a> {
15617     inner: ConformanceVersion,
15618     marker: ::std::marker::PhantomData<&'a ()>,
15619 }
15620 impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> {
15621     type Target = ConformanceVersion;
deref(&self) -> &Self::Target15622     fn deref(&self) -> &Self::Target {
15623         &self.inner
15624     }
15625 }
15626 impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15627     fn deref_mut(&mut self) -> &mut Self::Target {
15628         &mut self.inner
15629     }
15630 }
15631 impl<'a> ConformanceVersionBuilder<'a> {
major(mut self, major: u8) -> ConformanceVersionBuilder<'a>15632     pub fn major(mut self, major: u8) -> ConformanceVersionBuilder<'a> {
15633         self.inner.major = major;
15634         self
15635     }
minor(mut self, minor: u8) -> ConformanceVersionBuilder<'a>15636     pub fn minor(mut self, minor: u8) -> ConformanceVersionBuilder<'a> {
15637         self.inner.minor = minor;
15638         self
15639     }
subminor(mut self, subminor: u8) -> ConformanceVersionBuilder<'a>15640     pub fn subminor(mut self, subminor: u8) -> ConformanceVersionBuilder<'a> {
15641         self.inner.subminor = subminor;
15642         self
15643     }
patch(mut self, patch: u8) -> ConformanceVersionBuilder<'a>15644     pub fn patch(mut self, patch: u8) -> ConformanceVersionBuilder<'a> {
15645         self.inner.patch = patch;
15646         self
15647     }
15648     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15649     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15650     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ConformanceVersion15651     pub fn build(self) -> ConformanceVersion {
15652         self.inner
15653     }
15654 }
15655 #[repr(C)]
15656 #[derive(Copy, Clone)]
15657 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDriverProperties.html>"]
15658 pub struct PhysicalDeviceDriverProperties {
15659     pub s_type: StructureType,
15660     pub p_next: *mut c_void,
15661     pub driver_id: DriverId,
15662     pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
15663     pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
15664     pub conformance_version: ConformanceVersion,
15665 }
15666 impl fmt::Debug for PhysicalDeviceDriverProperties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result15667     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
15668         fmt.debug_struct("PhysicalDeviceDriverProperties")
15669             .field("s_type", &self.s_type)
15670             .field("p_next", &self.p_next)
15671             .field("driver_id", &self.driver_id)
15672             .field("driver_name", &unsafe {
15673                 ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr() as *const c_char)
15674             })
15675             .field("driver_info", &unsafe {
15676                 ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr() as *const c_char)
15677             })
15678             .field("conformance_version", &self.conformance_version)
15679             .finish()
15680     }
15681 }
15682 impl ::std::default::Default for PhysicalDeviceDriverProperties {
default() -> PhysicalDeviceDriverProperties15683     fn default() -> PhysicalDeviceDriverProperties {
15684         PhysicalDeviceDriverProperties {
15685             s_type: StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES,
15686             p_next: ::std::ptr::null_mut(),
15687             driver_id: DriverId::default(),
15688             driver_name: unsafe { ::std::mem::zeroed() },
15689             driver_info: unsafe { ::std::mem::zeroed() },
15690             conformance_version: ConformanceVersion::default(),
15691         }
15692     }
15693 }
15694 impl PhysicalDeviceDriverProperties {
builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a>15695     pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> {
15696         PhysicalDeviceDriverPropertiesBuilder {
15697             inner: PhysicalDeviceDriverProperties::default(),
15698             marker: ::std::marker::PhantomData,
15699         }
15700     }
15701 }
15702 #[repr(transparent)]
15703 pub struct PhysicalDeviceDriverPropertiesBuilder<'a> {
15704     inner: PhysicalDeviceDriverProperties,
15705     marker: ::std::marker::PhantomData<&'a ()>,
15706 }
15707 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {}
15708 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {}
15709 impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> {
15710     type Target = PhysicalDeviceDriverProperties;
deref(&self) -> &Self::Target15711     fn deref(&self) -> &Self::Target {
15712         &self.inner
15713     }
15714 }
15715 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15716     fn deref_mut(&mut self) -> &mut Self::Target {
15717         &mut self.inner
15718     }
15719 }
15720 impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
driver_id(mut self, driver_id: DriverId) -> PhysicalDeviceDriverPropertiesBuilder<'a>15721     pub fn driver_id(mut self, driver_id: DriverId) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
15722         self.inner.driver_id = driver_id;
15723         self
15724     }
driver_name( mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE], ) -> PhysicalDeviceDriverPropertiesBuilder<'a>15725     pub fn driver_name(
15726         mut self,
15727         driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
15728     ) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
15729         self.inner.driver_name = driver_name;
15730         self
15731     }
driver_info( mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE], ) -> PhysicalDeviceDriverPropertiesBuilder<'a>15732     pub fn driver_info(
15733         mut self,
15734         driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
15735     ) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
15736         self.inner.driver_info = driver_info;
15737         self
15738     }
conformance_version( mut self, conformance_version: ConformanceVersion, ) -> PhysicalDeviceDriverPropertiesBuilder<'a>15739     pub fn conformance_version(
15740         mut self,
15741         conformance_version: ConformanceVersion,
15742     ) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
15743         self.inner.conformance_version = conformance_version;
15744         self
15745     }
15746     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15747     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15748     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDriverProperties15749     pub fn build(self) -> PhysicalDeviceDriverProperties {
15750         self.inner
15751     }
15752 }
15753 #[repr(C)]
15754 #[derive(Copy, Clone, Debug)]
15755 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentRegionsKHR.html>"]
15756 pub struct PresentRegionsKHR {
15757     pub s_type: StructureType,
15758     pub p_next: *const c_void,
15759     pub swapchain_count: u32,
15760     pub p_regions: *const PresentRegionKHR,
15761 }
15762 impl ::std::default::Default for PresentRegionsKHR {
default() -> PresentRegionsKHR15763     fn default() -> PresentRegionsKHR {
15764         PresentRegionsKHR {
15765             s_type: StructureType::PRESENT_REGIONS_KHR,
15766             p_next: ::std::ptr::null(),
15767             swapchain_count: u32::default(),
15768             p_regions: ::std::ptr::null(),
15769         }
15770     }
15771 }
15772 impl PresentRegionsKHR {
builder<'a>() -> PresentRegionsKHRBuilder<'a>15773     pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> {
15774         PresentRegionsKHRBuilder {
15775             inner: PresentRegionsKHR::default(),
15776             marker: ::std::marker::PhantomData,
15777         }
15778     }
15779 }
15780 #[repr(transparent)]
15781 pub struct PresentRegionsKHRBuilder<'a> {
15782     inner: PresentRegionsKHR,
15783     marker: ::std::marker::PhantomData<&'a ()>,
15784 }
15785 unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {}
15786 unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {}
15787 impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> {
15788     type Target = PresentRegionsKHR;
deref(&self) -> &Self::Target15789     fn deref(&self) -> &Self::Target {
15790         &self.inner
15791     }
15792 }
15793 impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15794     fn deref_mut(&mut self) -> &mut Self::Target {
15795         &mut self.inner
15796     }
15797 }
15798 impl<'a> PresentRegionsKHRBuilder<'a> {
regions(mut self, regions: &'a [PresentRegionKHR]) -> PresentRegionsKHRBuilder<'a>15799     pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> PresentRegionsKHRBuilder<'a> {
15800         self.inner.swapchain_count = regions.len() as _;
15801         self.inner.p_regions = regions.as_ptr();
15802         self
15803     }
15804     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15805     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15806     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentRegionsKHR15807     pub fn build(self) -> PresentRegionsKHR {
15808         self.inner
15809     }
15810 }
15811 #[repr(C)]
15812 #[derive(Copy, Clone, Debug)]
15813 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentRegionKHR.html>"]
15814 pub struct PresentRegionKHR {
15815     pub rectangle_count: u32,
15816     pub p_rectangles: *const RectLayerKHR,
15817 }
15818 impl ::std::default::Default for PresentRegionKHR {
default() -> PresentRegionKHR15819     fn default() -> PresentRegionKHR {
15820         PresentRegionKHR {
15821             rectangle_count: u32::default(),
15822             p_rectangles: ::std::ptr::null(),
15823         }
15824     }
15825 }
15826 impl PresentRegionKHR {
builder<'a>() -> PresentRegionKHRBuilder<'a>15827     pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> {
15828         PresentRegionKHRBuilder {
15829             inner: PresentRegionKHR::default(),
15830             marker: ::std::marker::PhantomData,
15831         }
15832     }
15833 }
15834 #[repr(transparent)]
15835 pub struct PresentRegionKHRBuilder<'a> {
15836     inner: PresentRegionKHR,
15837     marker: ::std::marker::PhantomData<&'a ()>,
15838 }
15839 impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> {
15840     type Target = PresentRegionKHR;
deref(&self) -> &Self::Target15841     fn deref(&self) -> &Self::Target {
15842         &self.inner
15843     }
15844 }
15845 impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15846     fn deref_mut(&mut self) -> &mut Self::Target {
15847         &mut self.inner
15848     }
15849 }
15850 impl<'a> PresentRegionKHRBuilder<'a> {
rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> PresentRegionKHRBuilder<'a>15851     pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> PresentRegionKHRBuilder<'a> {
15852         self.inner.rectangle_count = rectangles.len() as _;
15853         self.inner.p_rectangles = rectangles.as_ptr();
15854         self
15855     }
15856     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15857     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15858     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentRegionKHR15859     pub fn build(self) -> PresentRegionKHR {
15860         self.inner
15861     }
15862 }
15863 #[repr(C)]
15864 #[derive(Copy, Clone, Default, Debug)]
15865 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRectLayerKHR.html>"]
15866 pub struct RectLayerKHR {
15867     pub offset: Offset2D,
15868     pub extent: Extent2D,
15869     pub layer: u32,
15870 }
15871 impl RectLayerKHR {
builder<'a>() -> RectLayerKHRBuilder<'a>15872     pub fn builder<'a>() -> RectLayerKHRBuilder<'a> {
15873         RectLayerKHRBuilder {
15874             inner: RectLayerKHR::default(),
15875             marker: ::std::marker::PhantomData,
15876         }
15877     }
15878 }
15879 #[repr(transparent)]
15880 pub struct RectLayerKHRBuilder<'a> {
15881     inner: RectLayerKHR,
15882     marker: ::std::marker::PhantomData<&'a ()>,
15883 }
15884 impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> {
15885     type Target = RectLayerKHR;
deref(&self) -> &Self::Target15886     fn deref(&self) -> &Self::Target {
15887         &self.inner
15888     }
15889 }
15890 impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15891     fn deref_mut(&mut self) -> &mut Self::Target {
15892         &mut self.inner
15893     }
15894 }
15895 impl<'a> RectLayerKHRBuilder<'a> {
offset(mut self, offset: Offset2D) -> RectLayerKHRBuilder<'a>15896     pub fn offset(mut self, offset: Offset2D) -> RectLayerKHRBuilder<'a> {
15897         self.inner.offset = offset;
15898         self
15899     }
extent(mut self, extent: Extent2D) -> RectLayerKHRBuilder<'a>15900     pub fn extent(mut self, extent: Extent2D) -> RectLayerKHRBuilder<'a> {
15901         self.inner.extent = extent;
15902         self
15903     }
layer(mut self, layer: u32) -> RectLayerKHRBuilder<'a>15904     pub fn layer(mut self, layer: u32) -> RectLayerKHRBuilder<'a> {
15905         self.inner.layer = layer;
15906         self
15907     }
15908     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15909     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15910     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RectLayerKHR15911     pub fn build(self) -> RectLayerKHR {
15912         self.inner
15913     }
15914 }
15915 #[repr(C)]
15916 #[derive(Copy, Clone, Debug)]
15917 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html>"]
15918 pub struct PhysicalDeviceVariablePointersFeatures {
15919     pub s_type: StructureType,
15920     pub p_next: *mut c_void,
15921     pub variable_pointers_storage_buffer: Bool32,
15922     pub variable_pointers: Bool32,
15923 }
15924 impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures {
default() -> PhysicalDeviceVariablePointersFeatures15925     fn default() -> PhysicalDeviceVariablePointersFeatures {
15926         PhysicalDeviceVariablePointersFeatures {
15927             s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
15928             p_next: ::std::ptr::null_mut(),
15929             variable_pointers_storage_buffer: Bool32::default(),
15930             variable_pointers: Bool32::default(),
15931         }
15932     }
15933 }
15934 impl PhysicalDeviceVariablePointersFeatures {
builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a>15935     pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
15936         PhysicalDeviceVariablePointersFeaturesBuilder {
15937             inner: PhysicalDeviceVariablePointersFeatures::default(),
15938             marker: ::std::marker::PhantomData,
15939         }
15940     }
15941 }
15942 #[repr(transparent)]
15943 pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
15944     inner: PhysicalDeviceVariablePointersFeatures,
15945     marker: ::std::marker::PhantomData<&'a ()>,
15946 }
15947 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
15948 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {}
15949 impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
15950     type Target = PhysicalDeviceVariablePointersFeatures;
deref(&self) -> &Self::Target15951     fn deref(&self) -> &Self::Target {
15952         &self.inner
15953     }
15954 }
15955 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target15956     fn deref_mut(&mut self) -> &mut Self::Target {
15957         &mut self.inner
15958     }
15959 }
15960 impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
variable_pointers_storage_buffer( mut self, variable_pointers_storage_buffer: bool, ) -> PhysicalDeviceVariablePointersFeaturesBuilder<'a>15961     pub fn variable_pointers_storage_buffer(
15962         mut self,
15963         variable_pointers_storage_buffer: bool,
15964     ) -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
15965         self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
15966         self
15967     }
variable_pointers( mut self, variable_pointers: bool, ) -> PhysicalDeviceVariablePointersFeaturesBuilder<'a>15968     pub fn variable_pointers(
15969         mut self,
15970         variable_pointers: bool,
15971     ) -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
15972         self.inner.variable_pointers = variable_pointers.into();
15973         self
15974     }
15975     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
15976     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
15977     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVariablePointersFeatures15978     pub fn build(self) -> PhysicalDeviceVariablePointersFeatures {
15979         self.inner
15980     }
15981 }
15982 #[repr(C)]
15983 #[derive(Copy, Clone, Default, Debug)]
15984 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryProperties.html>"]
15985 pub struct ExternalMemoryProperties {
15986     pub external_memory_features: ExternalMemoryFeatureFlags,
15987     pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
15988     pub compatible_handle_types: ExternalMemoryHandleTypeFlags,
15989 }
15990 impl ExternalMemoryProperties {
builder<'a>() -> ExternalMemoryPropertiesBuilder<'a>15991     pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> {
15992         ExternalMemoryPropertiesBuilder {
15993             inner: ExternalMemoryProperties::default(),
15994             marker: ::std::marker::PhantomData,
15995         }
15996     }
15997 }
15998 #[repr(transparent)]
15999 pub struct ExternalMemoryPropertiesBuilder<'a> {
16000     inner: ExternalMemoryProperties,
16001     marker: ::std::marker::PhantomData<&'a ()>,
16002 }
16003 impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> {
16004     type Target = ExternalMemoryProperties;
deref(&self) -> &Self::Target16005     fn deref(&self) -> &Self::Target {
16006         &self.inner
16007     }
16008 }
16009 impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16010     fn deref_mut(&mut self) -> &mut Self::Target {
16011         &mut self.inner
16012     }
16013 }
16014 impl<'a> ExternalMemoryPropertiesBuilder<'a> {
external_memory_features( mut self, external_memory_features: ExternalMemoryFeatureFlags, ) -> ExternalMemoryPropertiesBuilder<'a>16015     pub fn external_memory_features(
16016         mut self,
16017         external_memory_features: ExternalMemoryFeatureFlags,
16018     ) -> ExternalMemoryPropertiesBuilder<'a> {
16019         self.inner.external_memory_features = external_memory_features;
16020         self
16021     }
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, ) -> ExternalMemoryPropertiesBuilder<'a>16022     pub fn export_from_imported_handle_types(
16023         mut self,
16024         export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
16025     ) -> ExternalMemoryPropertiesBuilder<'a> {
16026         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
16027         self
16028     }
compatible_handle_types( mut self, compatible_handle_types: ExternalMemoryHandleTypeFlags, ) -> ExternalMemoryPropertiesBuilder<'a>16029     pub fn compatible_handle_types(
16030         mut self,
16031         compatible_handle_types: ExternalMemoryHandleTypeFlags,
16032     ) -> ExternalMemoryPropertiesBuilder<'a> {
16033         self.inner.compatible_handle_types = compatible_handle_types;
16034         self
16035     }
16036     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16037     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16038     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryProperties16039     pub fn build(self) -> ExternalMemoryProperties {
16040         self.inner
16041     }
16042 }
16043 #[repr(C)]
16044 #[derive(Copy, Clone, Debug)]
16045 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>"]
16046 pub struct PhysicalDeviceExternalImageFormatInfo {
16047     pub s_type: StructureType,
16048     pub p_next: *const c_void,
16049     pub handle_type: ExternalMemoryHandleTypeFlags,
16050 }
16051 impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo {
default() -> PhysicalDeviceExternalImageFormatInfo16052     fn default() -> PhysicalDeviceExternalImageFormatInfo {
16053         PhysicalDeviceExternalImageFormatInfo {
16054             s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
16055             p_next: ::std::ptr::null(),
16056             handle_type: ExternalMemoryHandleTypeFlags::default(),
16057         }
16058     }
16059 }
16060 impl PhysicalDeviceExternalImageFormatInfo {
builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a>16061     pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16062         PhysicalDeviceExternalImageFormatInfoBuilder {
16063             inner: PhysicalDeviceExternalImageFormatInfo::default(),
16064             marker: ::std::marker::PhantomData,
16065         }
16066     }
16067 }
16068 #[repr(transparent)]
16069 pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16070     inner: PhysicalDeviceExternalImageFormatInfo,
16071     marker: ::std::marker::PhantomData<&'a ()>,
16072 }
16073 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
16074     for PhysicalDeviceExternalImageFormatInfoBuilder<'_>
16075 {
16076 }
16077 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {}
16078 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16079     type Target = PhysicalDeviceExternalImageFormatInfo;
deref(&self) -> &Self::Target16080     fn deref(&self) -> &Self::Target {
16081         &self.inner
16082     }
16083 }
16084 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16085     fn deref_mut(&mut self) -> &mut Self::Target {
16086         &mut self.inner
16087     }
16088 }
16089 impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlags, ) -> PhysicalDeviceExternalImageFormatInfoBuilder<'a>16090     pub fn handle_type(
16091         mut self,
16092         handle_type: ExternalMemoryHandleTypeFlags,
16093     ) -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
16094         self.inner.handle_type = handle_type;
16095         self
16096     }
16097     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16098     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16099     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalImageFormatInfo16100     pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo {
16101         self.inner
16102     }
16103 }
16104 #[repr(C)]
16105 #[derive(Copy, Clone, Debug)]
16106 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalImageFormatProperties.html>"]
16107 pub struct ExternalImageFormatProperties {
16108     pub s_type: StructureType,
16109     pub p_next: *mut c_void,
16110     pub external_memory_properties: ExternalMemoryProperties,
16111 }
16112 impl ::std::default::Default for ExternalImageFormatProperties {
default() -> ExternalImageFormatProperties16113     fn default() -> ExternalImageFormatProperties {
16114         ExternalImageFormatProperties {
16115             s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES,
16116             p_next: ::std::ptr::null_mut(),
16117             external_memory_properties: ExternalMemoryProperties::default(),
16118         }
16119     }
16120 }
16121 impl ExternalImageFormatProperties {
builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a>16122     pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> {
16123         ExternalImageFormatPropertiesBuilder {
16124             inner: ExternalImageFormatProperties::default(),
16125             marker: ::std::marker::PhantomData,
16126         }
16127     }
16128 }
16129 #[repr(transparent)]
16130 pub struct ExternalImageFormatPropertiesBuilder<'a> {
16131     inner: ExternalImageFormatProperties,
16132     marker: ::std::marker::PhantomData<&'a ()>,
16133 }
16134 unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {}
16135 unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {}
16136 impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> {
16137     type Target = ExternalImageFormatProperties;
deref(&self) -> &Self::Target16138     fn deref(&self) -> &Self::Target {
16139         &self.inner
16140     }
16141 }
16142 impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16143     fn deref_mut(&mut self) -> &mut Self::Target {
16144         &mut self.inner
16145     }
16146 }
16147 impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
external_memory_properties( mut self, external_memory_properties: ExternalMemoryProperties, ) -> ExternalImageFormatPropertiesBuilder<'a>16148     pub fn external_memory_properties(
16149         mut self,
16150         external_memory_properties: ExternalMemoryProperties,
16151     ) -> ExternalImageFormatPropertiesBuilder<'a> {
16152         self.inner.external_memory_properties = external_memory_properties;
16153         self
16154     }
16155     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16156     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16157     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalImageFormatProperties16158     pub fn build(self) -> ExternalImageFormatProperties {
16159         self.inner
16160     }
16161 }
16162 #[repr(C)]
16163 #[derive(Copy, Clone, Debug)]
16164 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html>"]
16165 pub struct PhysicalDeviceExternalBufferInfo {
16166     pub s_type: StructureType,
16167     pub p_next: *const c_void,
16168     pub flags: BufferCreateFlags,
16169     pub usage: BufferUsageFlags,
16170     pub handle_type: ExternalMemoryHandleTypeFlags,
16171 }
16172 impl ::std::default::Default for PhysicalDeviceExternalBufferInfo {
default() -> PhysicalDeviceExternalBufferInfo16173     fn default() -> PhysicalDeviceExternalBufferInfo {
16174         PhysicalDeviceExternalBufferInfo {
16175             s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
16176             p_next: ::std::ptr::null(),
16177             flags: BufferCreateFlags::default(),
16178             usage: BufferUsageFlags::default(),
16179             handle_type: ExternalMemoryHandleTypeFlags::default(),
16180         }
16181     }
16182 }
16183 impl PhysicalDeviceExternalBufferInfo {
builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a>16184     pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
16185         PhysicalDeviceExternalBufferInfoBuilder {
16186             inner: PhysicalDeviceExternalBufferInfo::default(),
16187             marker: ::std::marker::PhantomData,
16188         }
16189     }
16190 }
16191 #[repr(transparent)]
16192 pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> {
16193     inner: PhysicalDeviceExternalBufferInfo,
16194     marker: ::std::marker::PhantomData<&'a ()>,
16195 }
16196 pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo {}
16197 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> {
16198     type Target = PhysicalDeviceExternalBufferInfo;
deref(&self) -> &Self::Target16199     fn deref(&self) -> &Self::Target {
16200         &self.inner
16201     }
16202 }
16203 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16204     fn deref_mut(&mut self) -> &mut Self::Target {
16205         &mut self.inner
16206     }
16207 }
16208 impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
flags( mut self, flags: BufferCreateFlags, ) -> PhysicalDeviceExternalBufferInfoBuilder<'a>16209     pub fn flags(
16210         mut self,
16211         flags: BufferCreateFlags,
16212     ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
16213         self.inner.flags = flags;
16214         self
16215     }
usage(mut self, usage: BufferUsageFlags) -> PhysicalDeviceExternalBufferInfoBuilder<'a>16216     pub fn usage(mut self, usage: BufferUsageFlags) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
16217         self.inner.usage = usage;
16218         self
16219     }
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlags, ) -> PhysicalDeviceExternalBufferInfoBuilder<'a>16220     pub fn handle_type(
16221         mut self,
16222         handle_type: ExternalMemoryHandleTypeFlags,
16223     ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
16224         self.inner.handle_type = handle_type;
16225         self
16226     }
16227     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
16228     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
16229     #[doc = r" valid extension structs can be pushed into the chain."]
16230     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
16231     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceExternalBufferInfo>( mut self, next: &'a mut T, ) -> PhysicalDeviceExternalBufferInfoBuilder<'a>16232     pub fn push_next<T: ExtendsPhysicalDeviceExternalBufferInfo>(
16233         mut self,
16234         next: &'a mut T,
16235     ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
16236         unsafe {
16237             let next_ptr = next as *mut T as *mut BaseOutStructure;
16238             let last_next = ptr_chain_iter(next).last().unwrap();
16239             (*last_next).p_next = self.inner.p_next as _;
16240             self.inner.p_next = next_ptr as _;
16241         }
16242         self
16243     }
16244     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16245     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16246     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalBufferInfo16247     pub fn build(self) -> PhysicalDeviceExternalBufferInfo {
16248         self.inner
16249     }
16250 }
16251 #[repr(C)]
16252 #[derive(Copy, Clone, Debug)]
16253 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalBufferProperties.html>"]
16254 pub struct ExternalBufferProperties {
16255     pub s_type: StructureType,
16256     pub p_next: *mut c_void,
16257     pub external_memory_properties: ExternalMemoryProperties,
16258 }
16259 impl ::std::default::Default for ExternalBufferProperties {
default() -> ExternalBufferProperties16260     fn default() -> ExternalBufferProperties {
16261         ExternalBufferProperties {
16262             s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES,
16263             p_next: ::std::ptr::null_mut(),
16264             external_memory_properties: ExternalMemoryProperties::default(),
16265         }
16266     }
16267 }
16268 impl ExternalBufferProperties {
builder<'a>() -> ExternalBufferPropertiesBuilder<'a>16269     pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> {
16270         ExternalBufferPropertiesBuilder {
16271             inner: ExternalBufferProperties::default(),
16272             marker: ::std::marker::PhantomData,
16273         }
16274     }
16275 }
16276 #[repr(transparent)]
16277 pub struct ExternalBufferPropertiesBuilder<'a> {
16278     inner: ExternalBufferProperties,
16279     marker: ::std::marker::PhantomData<&'a ()>,
16280 }
16281 pub unsafe trait ExtendsExternalBufferProperties {}
16282 impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> {
16283     type Target = ExternalBufferProperties;
deref(&self) -> &Self::Target16284     fn deref(&self) -> &Self::Target {
16285         &self.inner
16286     }
16287 }
16288 impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16289     fn deref_mut(&mut self) -> &mut Self::Target {
16290         &mut self.inner
16291     }
16292 }
16293 impl<'a> ExternalBufferPropertiesBuilder<'a> {
external_memory_properties( mut self, external_memory_properties: ExternalMemoryProperties, ) -> ExternalBufferPropertiesBuilder<'a>16294     pub fn external_memory_properties(
16295         mut self,
16296         external_memory_properties: ExternalMemoryProperties,
16297     ) -> ExternalBufferPropertiesBuilder<'a> {
16298         self.inner.external_memory_properties = external_memory_properties;
16299         self
16300     }
16301     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
16302     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
16303     #[doc = r" valid extension structs can be pushed into the chain."]
16304     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
16305     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsExternalBufferProperties>( mut self, next: &'a mut T, ) -> ExternalBufferPropertiesBuilder<'a>16306     pub fn push_next<T: ExtendsExternalBufferProperties>(
16307         mut self,
16308         next: &'a mut T,
16309     ) -> ExternalBufferPropertiesBuilder<'a> {
16310         unsafe {
16311             let next_ptr = next as *mut T as *mut BaseOutStructure;
16312             let last_next = ptr_chain_iter(next).last().unwrap();
16313             (*last_next).p_next = self.inner.p_next as _;
16314             self.inner.p_next = next_ptr as _;
16315         }
16316         self
16317     }
16318     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16319     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16320     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalBufferProperties16321     pub fn build(self) -> ExternalBufferProperties {
16322         self.inner
16323     }
16324 }
16325 #[repr(C)]
16326 #[derive(Copy, Clone, Debug)]
16327 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceIDProperties.html>"]
16328 pub struct PhysicalDeviceIDProperties {
16329     pub s_type: StructureType,
16330     pub p_next: *mut c_void,
16331     pub device_uuid: [u8; UUID_SIZE],
16332     pub driver_uuid: [u8; UUID_SIZE],
16333     pub device_luid: [u8; LUID_SIZE],
16334     pub device_node_mask: u32,
16335     pub device_luid_valid: Bool32,
16336 }
16337 impl ::std::default::Default for PhysicalDeviceIDProperties {
default() -> PhysicalDeviceIDProperties16338     fn default() -> PhysicalDeviceIDProperties {
16339         PhysicalDeviceIDProperties {
16340             s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES,
16341             p_next: ::std::ptr::null_mut(),
16342             device_uuid: unsafe { ::std::mem::zeroed() },
16343             driver_uuid: unsafe { ::std::mem::zeroed() },
16344             device_luid: unsafe { ::std::mem::zeroed() },
16345             device_node_mask: u32::default(),
16346             device_luid_valid: Bool32::default(),
16347         }
16348     }
16349 }
16350 impl PhysicalDeviceIDProperties {
builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a>16351     pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> {
16352         PhysicalDeviceIDPropertiesBuilder {
16353             inner: PhysicalDeviceIDProperties::default(),
16354             marker: ::std::marker::PhantomData,
16355         }
16356     }
16357 }
16358 #[repr(transparent)]
16359 pub struct PhysicalDeviceIDPropertiesBuilder<'a> {
16360     inner: PhysicalDeviceIDProperties,
16361     marker: ::std::marker::PhantomData<&'a ()>,
16362 }
16363 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {}
16364 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {}
16365 impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> {
16366     type Target = PhysicalDeviceIDProperties;
deref(&self) -> &Self::Target16367     fn deref(&self) -> &Self::Target {
16368         &self.inner
16369     }
16370 }
16371 impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16372     fn deref_mut(&mut self) -> &mut Self::Target {
16373         &mut self.inner
16374     }
16375 }
16376 impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
device_uuid( mut self, device_uuid: [u8; UUID_SIZE], ) -> PhysicalDeviceIDPropertiesBuilder<'a>16377     pub fn device_uuid(
16378         mut self,
16379         device_uuid: [u8; UUID_SIZE],
16380     ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
16381         self.inner.device_uuid = device_uuid;
16382         self
16383     }
driver_uuid( mut self, driver_uuid: [u8; UUID_SIZE], ) -> PhysicalDeviceIDPropertiesBuilder<'a>16384     pub fn driver_uuid(
16385         mut self,
16386         driver_uuid: [u8; UUID_SIZE],
16387     ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
16388         self.inner.driver_uuid = driver_uuid;
16389         self
16390     }
device_luid( mut self, device_luid: [u8; LUID_SIZE], ) -> PhysicalDeviceIDPropertiesBuilder<'a>16391     pub fn device_luid(
16392         mut self,
16393         device_luid: [u8; LUID_SIZE],
16394     ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
16395         self.inner.device_luid = device_luid;
16396         self
16397     }
device_node_mask( mut self, device_node_mask: u32, ) -> PhysicalDeviceIDPropertiesBuilder<'a>16398     pub fn device_node_mask(
16399         mut self,
16400         device_node_mask: u32,
16401     ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
16402         self.inner.device_node_mask = device_node_mask;
16403         self
16404     }
device_luid_valid( mut self, device_luid_valid: bool, ) -> PhysicalDeviceIDPropertiesBuilder<'a>16405     pub fn device_luid_valid(
16406         mut self,
16407         device_luid_valid: bool,
16408     ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
16409         self.inner.device_luid_valid = device_luid_valid.into();
16410         self
16411     }
16412     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16413     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16414     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceIDProperties16415     pub fn build(self) -> PhysicalDeviceIDProperties {
16416         self.inner
16417     }
16418 }
16419 #[repr(C)]
16420 #[derive(Copy, Clone, Debug)]
16421 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryImageCreateInfo.html>"]
16422 pub struct ExternalMemoryImageCreateInfo {
16423     pub s_type: StructureType,
16424     pub p_next: *const c_void,
16425     pub handle_types: ExternalMemoryHandleTypeFlags,
16426 }
16427 impl ::std::default::Default for ExternalMemoryImageCreateInfo {
default() -> ExternalMemoryImageCreateInfo16428     fn default() -> ExternalMemoryImageCreateInfo {
16429         ExternalMemoryImageCreateInfo {
16430             s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
16431             p_next: ::std::ptr::null(),
16432             handle_types: ExternalMemoryHandleTypeFlags::default(),
16433         }
16434     }
16435 }
16436 impl ExternalMemoryImageCreateInfo {
builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a>16437     pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> {
16438         ExternalMemoryImageCreateInfoBuilder {
16439             inner: ExternalMemoryImageCreateInfo::default(),
16440             marker: ::std::marker::PhantomData,
16441         }
16442     }
16443 }
16444 #[repr(transparent)]
16445 pub struct ExternalMemoryImageCreateInfoBuilder<'a> {
16446     inner: ExternalMemoryImageCreateInfo,
16447     marker: ::std::marker::PhantomData<&'a ()>,
16448 }
16449 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {}
16450 unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {}
16451 impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> {
16452     type Target = ExternalMemoryImageCreateInfo;
deref(&self) -> &Self::Target16453     fn deref(&self) -> &Self::Target {
16454         &self.inner
16455     }
16456 }
16457 impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16458     fn deref_mut(&mut self) -> &mut Self::Target {
16459         &mut self.inner
16460     }
16461 }
16462 impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
handle_types( mut self, handle_types: ExternalMemoryHandleTypeFlags, ) -> ExternalMemoryImageCreateInfoBuilder<'a>16463     pub fn handle_types(
16464         mut self,
16465         handle_types: ExternalMemoryHandleTypeFlags,
16466     ) -> ExternalMemoryImageCreateInfoBuilder<'a> {
16467         self.inner.handle_types = handle_types;
16468         self
16469     }
16470     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16471     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16472     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryImageCreateInfo16473     pub fn build(self) -> ExternalMemoryImageCreateInfo {
16474         self.inner
16475     }
16476 }
16477 #[repr(C)]
16478 #[derive(Copy, Clone, Debug)]
16479 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryBufferCreateInfo.html>"]
16480 pub struct ExternalMemoryBufferCreateInfo {
16481     pub s_type: StructureType,
16482     pub p_next: *const c_void,
16483     pub handle_types: ExternalMemoryHandleTypeFlags,
16484 }
16485 impl ::std::default::Default for ExternalMemoryBufferCreateInfo {
default() -> ExternalMemoryBufferCreateInfo16486     fn default() -> ExternalMemoryBufferCreateInfo {
16487         ExternalMemoryBufferCreateInfo {
16488             s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
16489             p_next: ::std::ptr::null(),
16490             handle_types: ExternalMemoryHandleTypeFlags::default(),
16491         }
16492     }
16493 }
16494 impl ExternalMemoryBufferCreateInfo {
builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a>16495     pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> {
16496         ExternalMemoryBufferCreateInfoBuilder {
16497             inner: ExternalMemoryBufferCreateInfo::default(),
16498             marker: ::std::marker::PhantomData,
16499         }
16500     }
16501 }
16502 #[repr(transparent)]
16503 pub struct ExternalMemoryBufferCreateInfoBuilder<'a> {
16504     inner: ExternalMemoryBufferCreateInfo,
16505     marker: ::std::marker::PhantomData<&'a ()>,
16506 }
16507 unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {}
16508 unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {}
16509 impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> {
16510     type Target = ExternalMemoryBufferCreateInfo;
deref(&self) -> &Self::Target16511     fn deref(&self) -> &Self::Target {
16512         &self.inner
16513     }
16514 }
16515 impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16516     fn deref_mut(&mut self) -> &mut Self::Target {
16517         &mut self.inner
16518     }
16519 }
16520 impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
handle_types( mut self, handle_types: ExternalMemoryHandleTypeFlags, ) -> ExternalMemoryBufferCreateInfoBuilder<'a>16521     pub fn handle_types(
16522         mut self,
16523         handle_types: ExternalMemoryHandleTypeFlags,
16524     ) -> ExternalMemoryBufferCreateInfoBuilder<'a> {
16525         self.inner.handle_types = handle_types;
16526         self
16527     }
16528     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16529     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16530     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalMemoryBufferCreateInfo16531     pub fn build(self) -> ExternalMemoryBufferCreateInfo {
16532         self.inner
16533     }
16534 }
16535 #[repr(C)]
16536 #[derive(Copy, Clone, Debug)]
16537 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryAllocateInfo.html>"]
16538 pub struct ExportMemoryAllocateInfo {
16539     pub s_type: StructureType,
16540     pub p_next: *const c_void,
16541     pub handle_types: ExternalMemoryHandleTypeFlags,
16542 }
16543 impl ::std::default::Default for ExportMemoryAllocateInfo {
default() -> ExportMemoryAllocateInfo16544     fn default() -> ExportMemoryAllocateInfo {
16545         ExportMemoryAllocateInfo {
16546             s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO,
16547             p_next: ::std::ptr::null(),
16548             handle_types: ExternalMemoryHandleTypeFlags::default(),
16549         }
16550     }
16551 }
16552 impl ExportMemoryAllocateInfo {
builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a>16553     pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> {
16554         ExportMemoryAllocateInfoBuilder {
16555             inner: ExportMemoryAllocateInfo::default(),
16556             marker: ::std::marker::PhantomData,
16557         }
16558     }
16559 }
16560 #[repr(transparent)]
16561 pub struct ExportMemoryAllocateInfoBuilder<'a> {
16562     inner: ExportMemoryAllocateInfo,
16563     marker: ::std::marker::PhantomData<&'a ()>,
16564 }
16565 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {}
16566 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {}
16567 impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> {
16568     type Target = ExportMemoryAllocateInfo;
deref(&self) -> &Self::Target16569     fn deref(&self) -> &Self::Target {
16570         &self.inner
16571     }
16572 }
16573 impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16574     fn deref_mut(&mut self) -> &mut Self::Target {
16575         &mut self.inner
16576     }
16577 }
16578 impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
handle_types( mut self, handle_types: ExternalMemoryHandleTypeFlags, ) -> ExportMemoryAllocateInfoBuilder<'a>16579     pub fn handle_types(
16580         mut self,
16581         handle_types: ExternalMemoryHandleTypeFlags,
16582     ) -> ExportMemoryAllocateInfoBuilder<'a> {
16583         self.inner.handle_types = handle_types;
16584         self
16585     }
16586     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16587     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16588     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryAllocateInfo16589     pub fn build(self) -> ExportMemoryAllocateInfo {
16590         self.inner
16591     }
16592 }
16593 #[repr(C)]
16594 #[derive(Copy, Clone, Debug)]
16595 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html>"]
16596 pub struct ImportMemoryWin32HandleInfoKHR {
16597     pub s_type: StructureType,
16598     pub p_next: *const c_void,
16599     pub handle_type: ExternalMemoryHandleTypeFlags,
16600     pub handle: HANDLE,
16601     pub name: LPCWSTR,
16602 }
16603 impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR {
default() -> ImportMemoryWin32HandleInfoKHR16604     fn default() -> ImportMemoryWin32HandleInfoKHR {
16605         ImportMemoryWin32HandleInfoKHR {
16606             s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
16607             p_next: ::std::ptr::null(),
16608             handle_type: ExternalMemoryHandleTypeFlags::default(),
16609             handle: unsafe { ::std::mem::zeroed() },
16610             name: unsafe { ::std::mem::zeroed() },
16611         }
16612     }
16613 }
16614 impl ImportMemoryWin32HandleInfoKHR {
builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a>16615     pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16616         ImportMemoryWin32HandleInfoKHRBuilder {
16617             inner: ImportMemoryWin32HandleInfoKHR::default(),
16618             marker: ::std::marker::PhantomData,
16619         }
16620     }
16621 }
16622 #[repr(transparent)]
16623 pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16624     inner: ImportMemoryWin32HandleInfoKHR,
16625     marker: ::std::marker::PhantomData<&'a ()>,
16626 }
16627 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {}
16628 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {}
16629 impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16630     type Target = ImportMemoryWin32HandleInfoKHR;
deref(&self) -> &Self::Target16631     fn deref(&self) -> &Self::Target {
16632         &self.inner
16633     }
16634 }
16635 impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16636     fn deref_mut(&mut self) -> &mut Self::Target {
16637         &mut self.inner
16638     }
16639 }
16640 impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlags, ) -> ImportMemoryWin32HandleInfoKHRBuilder<'a>16641     pub fn handle_type(
16642         mut self,
16643         handle_type: ExternalMemoryHandleTypeFlags,
16644     ) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16645         self.inner.handle_type = handle_type;
16646         self
16647     }
handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoKHRBuilder<'a>16648     pub fn handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16649         self.inner.handle = handle;
16650         self
16651     }
name(mut self, name: LPCWSTR) -> ImportMemoryWin32HandleInfoKHRBuilder<'a>16652     pub fn name(mut self, name: LPCWSTR) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
16653         self.inner.name = name;
16654         self
16655     }
16656     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16657     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16658     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryWin32HandleInfoKHR16659     pub fn build(self) -> ImportMemoryWin32HandleInfoKHR {
16660         self.inner
16661     }
16662 }
16663 #[repr(C)]
16664 #[derive(Copy, Clone, Debug)]
16665 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html>"]
16666 pub struct ExportMemoryWin32HandleInfoKHR {
16667     pub s_type: StructureType,
16668     pub p_next: *const c_void,
16669     pub p_attributes: *const SECURITY_ATTRIBUTES,
16670     pub dw_access: DWORD,
16671     pub name: LPCWSTR,
16672 }
16673 impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR {
default() -> ExportMemoryWin32HandleInfoKHR16674     fn default() -> ExportMemoryWin32HandleInfoKHR {
16675         ExportMemoryWin32HandleInfoKHR {
16676             s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
16677             p_next: ::std::ptr::null(),
16678             p_attributes: ::std::ptr::null(),
16679             dw_access: DWORD::default(),
16680             name: unsafe { ::std::mem::zeroed() },
16681         }
16682     }
16683 }
16684 impl ExportMemoryWin32HandleInfoKHR {
builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a>16685     pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16686         ExportMemoryWin32HandleInfoKHRBuilder {
16687             inner: ExportMemoryWin32HandleInfoKHR::default(),
16688             marker: ::std::marker::PhantomData,
16689         }
16690     }
16691 }
16692 #[repr(transparent)]
16693 pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16694     inner: ExportMemoryWin32HandleInfoKHR,
16695     marker: ::std::marker::PhantomData<&'a ()>,
16696 }
16697 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {}
16698 unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {}
16699 impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16700     type Target = ExportMemoryWin32HandleInfoKHR;
deref(&self) -> &Self::Target16701     fn deref(&self) -> &Self::Target {
16702         &self.inner
16703     }
16704 }
16705 impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16706     fn deref_mut(&mut self) -> &mut Self::Target {
16707         &mut self.inner
16708     }
16709 }
16710 impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
attributes( mut self, attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportMemoryWin32HandleInfoKHRBuilder<'a>16711     pub fn attributes(
16712         mut self,
16713         attributes: &'a SECURITY_ATTRIBUTES,
16714     ) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16715         self.inner.p_attributes = attributes;
16716         self
16717     }
dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoKHRBuilder<'a>16718     pub fn dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16719         self.inner.dw_access = dw_access;
16720         self
16721     }
name(mut self, name: LPCWSTR) -> ExportMemoryWin32HandleInfoKHRBuilder<'a>16722     pub fn name(mut self, name: LPCWSTR) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
16723         self.inner.name = name;
16724         self
16725     }
16726     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16727     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16728     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportMemoryWin32HandleInfoKHR16729     pub fn build(self) -> ExportMemoryWin32HandleInfoKHR {
16730         self.inner
16731     }
16732 }
16733 #[repr(C)]
16734 #[derive(Copy, Clone, Debug)]
16735 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html>"]
16736 pub struct MemoryWin32HandlePropertiesKHR {
16737     pub s_type: StructureType,
16738     pub p_next: *mut c_void,
16739     pub memory_type_bits: u32,
16740 }
16741 impl ::std::default::Default for MemoryWin32HandlePropertiesKHR {
default() -> MemoryWin32HandlePropertiesKHR16742     fn default() -> MemoryWin32HandlePropertiesKHR {
16743         MemoryWin32HandlePropertiesKHR {
16744             s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
16745             p_next: ::std::ptr::null_mut(),
16746             memory_type_bits: u32::default(),
16747         }
16748     }
16749 }
16750 impl MemoryWin32HandlePropertiesKHR {
builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a>16751     pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
16752         MemoryWin32HandlePropertiesKHRBuilder {
16753             inner: MemoryWin32HandlePropertiesKHR::default(),
16754             marker: ::std::marker::PhantomData,
16755         }
16756     }
16757 }
16758 #[repr(transparent)]
16759 pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> {
16760     inner: MemoryWin32HandlePropertiesKHR,
16761     marker: ::std::marker::PhantomData<&'a ()>,
16762 }
16763 pub unsafe trait ExtendsMemoryWin32HandlePropertiesKHR {}
16764 impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> {
16765     type Target = MemoryWin32HandlePropertiesKHR;
deref(&self) -> &Self::Target16766     fn deref(&self) -> &Self::Target {
16767         &self.inner
16768     }
16769 }
16770 impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16771     fn deref_mut(&mut self) -> &mut Self::Target {
16772         &mut self.inner
16773     }
16774 }
16775 impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
memory_type_bits( mut self, memory_type_bits: u32, ) -> MemoryWin32HandlePropertiesKHRBuilder<'a>16776     pub fn memory_type_bits(
16777         mut self,
16778         memory_type_bits: u32,
16779     ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
16780         self.inner.memory_type_bits = memory_type_bits;
16781         self
16782     }
16783     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
16784     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
16785     #[doc = r" valid extension structs can be pushed into the chain."]
16786     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
16787     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryWin32HandlePropertiesKHR>( mut self, next: &'a mut T, ) -> MemoryWin32HandlePropertiesKHRBuilder<'a>16788     pub fn push_next<T: ExtendsMemoryWin32HandlePropertiesKHR>(
16789         mut self,
16790         next: &'a mut T,
16791     ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
16792         unsafe {
16793             let next_ptr = next as *mut T as *mut BaseOutStructure;
16794             let last_next = ptr_chain_iter(next).last().unwrap();
16795             (*last_next).p_next = self.inner.p_next as _;
16796             self.inner.p_next = next_ptr as _;
16797         }
16798         self
16799     }
16800     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16801     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16802     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryWin32HandlePropertiesKHR16803     pub fn build(self) -> MemoryWin32HandlePropertiesKHR {
16804         self.inner
16805     }
16806 }
16807 #[repr(C)]
16808 #[derive(Copy, Clone, Debug)]
16809 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html>"]
16810 pub struct MemoryGetWin32HandleInfoKHR {
16811     pub s_type: StructureType,
16812     pub p_next: *const c_void,
16813     pub memory: DeviceMemory,
16814     pub handle_type: ExternalMemoryHandleTypeFlags,
16815 }
16816 impl ::std::default::Default for MemoryGetWin32HandleInfoKHR {
default() -> MemoryGetWin32HandleInfoKHR16817     fn default() -> MemoryGetWin32HandleInfoKHR {
16818         MemoryGetWin32HandleInfoKHR {
16819             s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR,
16820             p_next: ::std::ptr::null(),
16821             memory: DeviceMemory::default(),
16822             handle_type: ExternalMemoryHandleTypeFlags::default(),
16823         }
16824     }
16825 }
16826 impl MemoryGetWin32HandleInfoKHR {
builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a>16827     pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
16828         MemoryGetWin32HandleInfoKHRBuilder {
16829             inner: MemoryGetWin32HandleInfoKHR::default(),
16830             marker: ::std::marker::PhantomData,
16831         }
16832     }
16833 }
16834 #[repr(transparent)]
16835 pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> {
16836     inner: MemoryGetWin32HandleInfoKHR,
16837     marker: ::std::marker::PhantomData<&'a ()>,
16838 }
16839 pub unsafe trait ExtendsMemoryGetWin32HandleInfoKHR {}
16840 impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> {
16841     type Target = MemoryGetWin32HandleInfoKHR;
deref(&self) -> &Self::Target16842     fn deref(&self) -> &Self::Target {
16843         &self.inner
16844     }
16845 }
16846 impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16847     fn deref_mut(&mut self) -> &mut Self::Target {
16848         &mut self.inner
16849     }
16850 }
16851 impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
memory(mut self, memory: DeviceMemory) -> MemoryGetWin32HandleInfoKHRBuilder<'a>16852     pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
16853         self.inner.memory = memory;
16854         self
16855     }
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlags, ) -> MemoryGetWin32HandleInfoKHRBuilder<'a>16856     pub fn handle_type(
16857         mut self,
16858         handle_type: ExternalMemoryHandleTypeFlags,
16859     ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
16860         self.inner.handle_type = handle_type;
16861         self
16862     }
16863     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
16864     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
16865     #[doc = r" valid extension structs can be pushed into the chain."]
16866     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
16867     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryGetWin32HandleInfoKHR>( mut self, next: &'a mut T, ) -> MemoryGetWin32HandleInfoKHRBuilder<'a>16868     pub fn push_next<T: ExtendsMemoryGetWin32HandleInfoKHR>(
16869         mut self,
16870         next: &'a mut T,
16871     ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
16872         unsafe {
16873             let next_ptr = next as *mut T as *mut BaseOutStructure;
16874             let last_next = ptr_chain_iter(next).last().unwrap();
16875             (*last_next).p_next = self.inner.p_next as _;
16876             self.inner.p_next = next_ptr as _;
16877         }
16878         self
16879     }
16880     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16881     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16882     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryGetWin32HandleInfoKHR16883     pub fn build(self) -> MemoryGetWin32HandleInfoKHR {
16884         self.inner
16885     }
16886 }
16887 #[repr(C)]
16888 #[derive(Copy, Clone, Debug)]
16889 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryFdInfoKHR.html>"]
16890 pub struct ImportMemoryFdInfoKHR {
16891     pub s_type: StructureType,
16892     pub p_next: *const c_void,
16893     pub handle_type: ExternalMemoryHandleTypeFlags,
16894     pub fd: c_int,
16895 }
16896 impl ::std::default::Default for ImportMemoryFdInfoKHR {
default() -> ImportMemoryFdInfoKHR16897     fn default() -> ImportMemoryFdInfoKHR {
16898         ImportMemoryFdInfoKHR {
16899             s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR,
16900             p_next: ::std::ptr::null(),
16901             handle_type: ExternalMemoryHandleTypeFlags::default(),
16902             fd: c_int::default(),
16903         }
16904     }
16905 }
16906 impl ImportMemoryFdInfoKHR {
builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a>16907     pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> {
16908         ImportMemoryFdInfoKHRBuilder {
16909             inner: ImportMemoryFdInfoKHR::default(),
16910             marker: ::std::marker::PhantomData,
16911         }
16912     }
16913 }
16914 #[repr(transparent)]
16915 pub struct ImportMemoryFdInfoKHRBuilder<'a> {
16916     inner: ImportMemoryFdInfoKHR,
16917     marker: ::std::marker::PhantomData<&'a ()>,
16918 }
16919 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {}
16920 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {}
16921 impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> {
16922     type Target = ImportMemoryFdInfoKHR;
deref(&self) -> &Self::Target16923     fn deref(&self) -> &Self::Target {
16924         &self.inner
16925     }
16926 }
16927 impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16928     fn deref_mut(&mut self) -> &mut Self::Target {
16929         &mut self.inner
16930     }
16931 }
16932 impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlags, ) -> ImportMemoryFdInfoKHRBuilder<'a>16933     pub fn handle_type(
16934         mut self,
16935         handle_type: ExternalMemoryHandleTypeFlags,
16936     ) -> ImportMemoryFdInfoKHRBuilder<'a> {
16937         self.inner.handle_type = handle_type;
16938         self
16939     }
fd(mut self, fd: c_int) -> ImportMemoryFdInfoKHRBuilder<'a>16940     pub fn fd(mut self, fd: c_int) -> ImportMemoryFdInfoKHRBuilder<'a> {
16941         self.inner.fd = fd;
16942         self
16943     }
16944     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
16945     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
16946     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryFdInfoKHR16947     pub fn build(self) -> ImportMemoryFdInfoKHR {
16948         self.inner
16949     }
16950 }
16951 #[repr(C)]
16952 #[derive(Copy, Clone, Debug)]
16953 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryFdPropertiesKHR.html>"]
16954 pub struct MemoryFdPropertiesKHR {
16955     pub s_type: StructureType,
16956     pub p_next: *mut c_void,
16957     pub memory_type_bits: u32,
16958 }
16959 impl ::std::default::Default for MemoryFdPropertiesKHR {
default() -> MemoryFdPropertiesKHR16960     fn default() -> MemoryFdPropertiesKHR {
16961         MemoryFdPropertiesKHR {
16962             s_type: StructureType::MEMORY_FD_PROPERTIES_KHR,
16963             p_next: ::std::ptr::null_mut(),
16964             memory_type_bits: u32::default(),
16965         }
16966     }
16967 }
16968 impl MemoryFdPropertiesKHR {
builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a>16969     pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> {
16970         MemoryFdPropertiesKHRBuilder {
16971             inner: MemoryFdPropertiesKHR::default(),
16972             marker: ::std::marker::PhantomData,
16973         }
16974     }
16975 }
16976 #[repr(transparent)]
16977 pub struct MemoryFdPropertiesKHRBuilder<'a> {
16978     inner: MemoryFdPropertiesKHR,
16979     marker: ::std::marker::PhantomData<&'a ()>,
16980 }
16981 pub unsafe trait ExtendsMemoryFdPropertiesKHR {}
16982 impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> {
16983     type Target = MemoryFdPropertiesKHR;
deref(&self) -> &Self::Target16984     fn deref(&self) -> &Self::Target {
16985         &self.inner
16986     }
16987 }
16988 impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target16989     fn deref_mut(&mut self) -> &mut Self::Target {
16990         &mut self.inner
16991     }
16992 }
16993 impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
memory_type_bits(mut self, memory_type_bits: u32) -> MemoryFdPropertiesKHRBuilder<'a>16994     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> MemoryFdPropertiesKHRBuilder<'a> {
16995         self.inner.memory_type_bits = memory_type_bits;
16996         self
16997     }
16998     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
16999     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17000     #[doc = r" valid extension structs can be pushed into the chain."]
17001     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17002     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryFdPropertiesKHR>( mut self, next: &'a mut T, ) -> MemoryFdPropertiesKHRBuilder<'a>17003     pub fn push_next<T: ExtendsMemoryFdPropertiesKHR>(
17004         mut self,
17005         next: &'a mut T,
17006     ) -> MemoryFdPropertiesKHRBuilder<'a> {
17007         unsafe {
17008             let next_ptr = next as *mut T as *mut BaseOutStructure;
17009             let last_next = ptr_chain_iter(next).last().unwrap();
17010             (*last_next).p_next = self.inner.p_next as _;
17011             self.inner.p_next = next_ptr as _;
17012         }
17013         self
17014     }
17015     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17016     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17017     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryFdPropertiesKHR17018     pub fn build(self) -> MemoryFdPropertiesKHR {
17019         self.inner
17020     }
17021 }
17022 #[repr(C)]
17023 #[derive(Copy, Clone, Debug)]
17024 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetFdInfoKHR.html>"]
17025 pub struct MemoryGetFdInfoKHR {
17026     pub s_type: StructureType,
17027     pub p_next: *const c_void,
17028     pub memory: DeviceMemory,
17029     pub handle_type: ExternalMemoryHandleTypeFlags,
17030 }
17031 impl ::std::default::Default for MemoryGetFdInfoKHR {
default() -> MemoryGetFdInfoKHR17032     fn default() -> MemoryGetFdInfoKHR {
17033         MemoryGetFdInfoKHR {
17034             s_type: StructureType::MEMORY_GET_FD_INFO_KHR,
17035             p_next: ::std::ptr::null(),
17036             memory: DeviceMemory::default(),
17037             handle_type: ExternalMemoryHandleTypeFlags::default(),
17038         }
17039     }
17040 }
17041 impl MemoryGetFdInfoKHR {
builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a>17042     pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> {
17043         MemoryGetFdInfoKHRBuilder {
17044             inner: MemoryGetFdInfoKHR::default(),
17045             marker: ::std::marker::PhantomData,
17046         }
17047     }
17048 }
17049 #[repr(transparent)]
17050 pub struct MemoryGetFdInfoKHRBuilder<'a> {
17051     inner: MemoryGetFdInfoKHR,
17052     marker: ::std::marker::PhantomData<&'a ()>,
17053 }
17054 pub unsafe trait ExtendsMemoryGetFdInfoKHR {}
17055 impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> {
17056     type Target = MemoryGetFdInfoKHR;
deref(&self) -> &Self::Target17057     fn deref(&self) -> &Self::Target {
17058         &self.inner
17059     }
17060 }
17061 impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17062     fn deref_mut(&mut self) -> &mut Self::Target {
17063         &mut self.inner
17064     }
17065 }
17066 impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
memory(mut self, memory: DeviceMemory) -> MemoryGetFdInfoKHRBuilder<'a>17067     pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetFdInfoKHRBuilder<'a> {
17068         self.inner.memory = memory;
17069         self
17070     }
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlags, ) -> MemoryGetFdInfoKHRBuilder<'a>17071     pub fn handle_type(
17072         mut self,
17073         handle_type: ExternalMemoryHandleTypeFlags,
17074     ) -> MemoryGetFdInfoKHRBuilder<'a> {
17075         self.inner.handle_type = handle_type;
17076         self
17077     }
17078     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17079     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17080     #[doc = r" valid extension structs can be pushed into the chain."]
17081     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17082     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryGetFdInfoKHR>( mut self, next: &'a mut T, ) -> MemoryGetFdInfoKHRBuilder<'a>17083     pub fn push_next<T: ExtendsMemoryGetFdInfoKHR>(
17084         mut self,
17085         next: &'a mut T,
17086     ) -> MemoryGetFdInfoKHRBuilder<'a> {
17087         unsafe {
17088             let next_ptr = next as *mut T as *mut BaseOutStructure;
17089             let last_next = ptr_chain_iter(next).last().unwrap();
17090             (*last_next).p_next = self.inner.p_next as _;
17091             self.inner.p_next = next_ptr as _;
17092         }
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."]
build(self) -> MemoryGetFdInfoKHR17098     pub fn build(self) -> MemoryGetFdInfoKHR {
17099         self.inner
17100     }
17101 }
17102 #[repr(C)]
17103 #[derive(Copy, Clone, Debug)]
17104 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>"]
17105 pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
17106     pub s_type: StructureType,
17107     pub p_next: *const c_void,
17108     pub acquire_count: u32,
17109     pub p_acquire_syncs: *const DeviceMemory,
17110     pub p_acquire_keys: *const u64,
17111     pub p_acquire_timeouts: *const u32,
17112     pub release_count: u32,
17113     pub p_release_syncs: *const DeviceMemory,
17114     pub p_release_keys: *const u64,
17115 }
17116 impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR {
default() -> Win32KeyedMutexAcquireReleaseInfoKHR17117     fn default() -> Win32KeyedMutexAcquireReleaseInfoKHR {
17118         Win32KeyedMutexAcquireReleaseInfoKHR {
17119             s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
17120             p_next: ::std::ptr::null(),
17121             acquire_count: u32::default(),
17122             p_acquire_syncs: ::std::ptr::null(),
17123             p_acquire_keys: ::std::ptr::null(),
17124             p_acquire_timeouts: ::std::ptr::null(),
17125             release_count: u32::default(),
17126             p_release_syncs: ::std::ptr::null(),
17127             p_release_keys: ::std::ptr::null(),
17128         }
17129     }
17130 }
17131 impl Win32KeyedMutexAcquireReleaseInfoKHR {
builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>17132     pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17133         Win32KeyedMutexAcquireReleaseInfoKHRBuilder {
17134             inner: Win32KeyedMutexAcquireReleaseInfoKHR::default(),
17135             marker: ::std::marker::PhantomData,
17136         }
17137     }
17138 }
17139 #[repr(transparent)]
17140 pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17141     inner: Win32KeyedMutexAcquireReleaseInfoKHR,
17142     marker: ::std::marker::PhantomData<&'a ()>,
17143 }
17144 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
17145 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {}
17146 impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17147     type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
deref(&self) -> &Self::Target17148     fn deref(&self) -> &Self::Target {
17149         &self.inner
17150     }
17151 }
17152 impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17153     fn deref_mut(&mut self) -> &mut Self::Target {
17154         &mut self.inner
17155     }
17156 }
17157 impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
acquire_syncs( mut self, acquire_syncs: &'a [DeviceMemory], ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>17158     pub fn acquire_syncs(
17159         mut self,
17160         acquire_syncs: &'a [DeviceMemory],
17161     ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17162         self.inner.acquire_count = acquire_syncs.len() as _;
17163         self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
17164         self
17165     }
acquire_keys( mut self, acquire_keys: &'a [u64], ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>17166     pub fn acquire_keys(
17167         mut self,
17168         acquire_keys: &'a [u64],
17169     ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17170         self.inner.acquire_count = acquire_keys.len() as _;
17171         self.inner.p_acquire_keys = acquire_keys.as_ptr();
17172         self
17173     }
acquire_timeouts( mut self, acquire_timeouts: &'a [u32], ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>17174     pub fn acquire_timeouts(
17175         mut self,
17176         acquire_timeouts: &'a [u32],
17177     ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17178         self.inner.acquire_count = acquire_timeouts.len() as _;
17179         self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr();
17180         self
17181     }
release_syncs( mut self, release_syncs: &'a [DeviceMemory], ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>17182     pub fn release_syncs(
17183         mut self,
17184         release_syncs: &'a [DeviceMemory],
17185     ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17186         self.inner.release_count = release_syncs.len() as _;
17187         self.inner.p_release_syncs = release_syncs.as_ptr();
17188         self
17189     }
release_keys( mut self, release_keys: &'a [u64], ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>17190     pub fn release_keys(
17191         mut self,
17192         release_keys: &'a [u64],
17193     ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
17194         self.inner.release_count = release_keys.len() as _;
17195         self.inner.p_release_keys = release_keys.as_ptr();
17196         self
17197     }
17198     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17199     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17200     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR17201     pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR {
17202         self.inner
17203     }
17204 }
17205 #[repr(C)]
17206 #[derive(Copy, Clone, Debug)]
17207 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>"]
17208 pub struct PhysicalDeviceExternalSemaphoreInfo {
17209     pub s_type: StructureType,
17210     pub p_next: *const c_void,
17211     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17212 }
17213 impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo {
default() -> PhysicalDeviceExternalSemaphoreInfo17214     fn default() -> PhysicalDeviceExternalSemaphoreInfo {
17215         PhysicalDeviceExternalSemaphoreInfo {
17216             s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
17217             p_next: ::std::ptr::null(),
17218             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17219         }
17220     }
17221 }
17222 impl PhysicalDeviceExternalSemaphoreInfo {
builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a>17223     pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17224         PhysicalDeviceExternalSemaphoreInfoBuilder {
17225             inner: PhysicalDeviceExternalSemaphoreInfo::default(),
17226             marker: ::std::marker::PhantomData,
17227         }
17228     }
17229 }
17230 #[repr(transparent)]
17231 pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17232     inner: PhysicalDeviceExternalSemaphoreInfo,
17233     marker: ::std::marker::PhantomData<&'a ()>,
17234 }
17235 pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {}
17236 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17237     type Target = PhysicalDeviceExternalSemaphoreInfo;
deref(&self) -> &Self::Target17238     fn deref(&self) -> &Self::Target {
17239         &self.inner
17240     }
17241 }
17242 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17243     fn deref_mut(&mut self) -> &mut Self::Target {
17244         &mut self.inner
17245     }
17246 }
17247 impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
handle_type( mut self, handle_type: ExternalSemaphoreHandleTypeFlags, ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a>17248     pub fn handle_type(
17249         mut self,
17250         handle_type: ExternalSemaphoreHandleTypeFlags,
17251     ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17252         self.inner.handle_type = handle_type;
17253         self
17254     }
17255     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17256     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17257     #[doc = r" valid extension structs can be pushed into the chain."]
17258     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17259     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>( mut self, next: &'a mut T, ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a>17260     pub fn push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>(
17261         mut self,
17262         next: &'a mut T,
17263     ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
17264         unsafe {
17265             let next_ptr = next as *mut T as *mut BaseOutStructure;
17266             let last_next = ptr_chain_iter(next).last().unwrap();
17267             (*last_next).p_next = self.inner.p_next as _;
17268             self.inner.p_next = next_ptr as _;
17269         }
17270         self
17271     }
17272     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17273     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17274     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalSemaphoreInfo17275     pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo {
17276         self.inner
17277     }
17278 }
17279 #[repr(C)]
17280 #[derive(Copy, Clone, Debug)]
17281 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreProperties.html>"]
17282 pub struct ExternalSemaphoreProperties {
17283     pub s_type: StructureType,
17284     pub p_next: *mut c_void,
17285     pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
17286     pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
17287     pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
17288 }
17289 impl ::std::default::Default for ExternalSemaphoreProperties {
default() -> ExternalSemaphoreProperties17290     fn default() -> ExternalSemaphoreProperties {
17291         ExternalSemaphoreProperties {
17292             s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES,
17293             p_next: ::std::ptr::null_mut(),
17294             export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
17295             compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
17296             external_semaphore_features: ExternalSemaphoreFeatureFlags::default(),
17297         }
17298     }
17299 }
17300 impl ExternalSemaphoreProperties {
builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a>17301     pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> {
17302         ExternalSemaphorePropertiesBuilder {
17303             inner: ExternalSemaphoreProperties::default(),
17304             marker: ::std::marker::PhantomData,
17305         }
17306     }
17307 }
17308 #[repr(transparent)]
17309 pub struct ExternalSemaphorePropertiesBuilder<'a> {
17310     inner: ExternalSemaphoreProperties,
17311     marker: ::std::marker::PhantomData<&'a ()>,
17312 }
17313 pub unsafe trait ExtendsExternalSemaphoreProperties {}
17314 impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> {
17315     type Target = ExternalSemaphoreProperties;
deref(&self) -> &Self::Target17316     fn deref(&self) -> &Self::Target {
17317         &self.inner
17318     }
17319 }
17320 impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17321     fn deref_mut(&mut self) -> &mut Self::Target {
17322         &mut self.inner
17323     }
17324 }
17325 impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, ) -> ExternalSemaphorePropertiesBuilder<'a>17326     pub fn export_from_imported_handle_types(
17327         mut self,
17328         export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
17329     ) -> ExternalSemaphorePropertiesBuilder<'a> {
17330         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
17331         self
17332     }
compatible_handle_types( mut self, compatible_handle_types: ExternalSemaphoreHandleTypeFlags, ) -> ExternalSemaphorePropertiesBuilder<'a>17333     pub fn compatible_handle_types(
17334         mut self,
17335         compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
17336     ) -> ExternalSemaphorePropertiesBuilder<'a> {
17337         self.inner.compatible_handle_types = compatible_handle_types;
17338         self
17339     }
external_semaphore_features( mut self, external_semaphore_features: ExternalSemaphoreFeatureFlags, ) -> ExternalSemaphorePropertiesBuilder<'a>17340     pub fn external_semaphore_features(
17341         mut self,
17342         external_semaphore_features: ExternalSemaphoreFeatureFlags,
17343     ) -> ExternalSemaphorePropertiesBuilder<'a> {
17344         self.inner.external_semaphore_features = external_semaphore_features;
17345         self
17346     }
17347     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17348     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17349     #[doc = r" valid extension structs can be pushed into the chain."]
17350     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17351     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsExternalSemaphoreProperties>( mut self, next: &'a mut T, ) -> ExternalSemaphorePropertiesBuilder<'a>17352     pub fn push_next<T: ExtendsExternalSemaphoreProperties>(
17353         mut self,
17354         next: &'a mut T,
17355     ) -> ExternalSemaphorePropertiesBuilder<'a> {
17356         unsafe {
17357             let next_ptr = next as *mut T as *mut BaseOutStructure;
17358             let last_next = ptr_chain_iter(next).last().unwrap();
17359             (*last_next).p_next = self.inner.p_next as _;
17360             self.inner.p_next = next_ptr as _;
17361         }
17362         self
17363     }
17364     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17365     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17366     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalSemaphoreProperties17367     pub fn build(self) -> ExternalSemaphoreProperties {
17368         self.inner
17369     }
17370 }
17371 #[repr(C)]
17372 #[derive(Copy, Clone, Debug)]
17373 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportSemaphoreCreateInfo.html>"]
17374 pub struct ExportSemaphoreCreateInfo {
17375     pub s_type: StructureType,
17376     pub p_next: *const c_void,
17377     pub handle_types: ExternalSemaphoreHandleTypeFlags,
17378 }
17379 impl ::std::default::Default for ExportSemaphoreCreateInfo {
default() -> ExportSemaphoreCreateInfo17380     fn default() -> ExportSemaphoreCreateInfo {
17381         ExportSemaphoreCreateInfo {
17382             s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO,
17383             p_next: ::std::ptr::null(),
17384             handle_types: ExternalSemaphoreHandleTypeFlags::default(),
17385         }
17386     }
17387 }
17388 impl ExportSemaphoreCreateInfo {
builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a>17389     pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> {
17390         ExportSemaphoreCreateInfoBuilder {
17391             inner: ExportSemaphoreCreateInfo::default(),
17392             marker: ::std::marker::PhantomData,
17393         }
17394     }
17395 }
17396 #[repr(transparent)]
17397 pub struct ExportSemaphoreCreateInfoBuilder<'a> {
17398     inner: ExportSemaphoreCreateInfo,
17399     marker: ::std::marker::PhantomData<&'a ()>,
17400 }
17401 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {}
17402 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {}
17403 impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> {
17404     type Target = ExportSemaphoreCreateInfo;
deref(&self) -> &Self::Target17405     fn deref(&self) -> &Self::Target {
17406         &self.inner
17407     }
17408 }
17409 impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17410     fn deref_mut(&mut self) -> &mut Self::Target {
17411         &mut self.inner
17412     }
17413 }
17414 impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
handle_types( mut self, handle_types: ExternalSemaphoreHandleTypeFlags, ) -> ExportSemaphoreCreateInfoBuilder<'a>17415     pub fn handle_types(
17416         mut self,
17417         handle_types: ExternalSemaphoreHandleTypeFlags,
17418     ) -> ExportSemaphoreCreateInfoBuilder<'a> {
17419         self.inner.handle_types = handle_types;
17420         self
17421     }
17422     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17423     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17424     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportSemaphoreCreateInfo17425     pub fn build(self) -> ExportSemaphoreCreateInfo {
17426         self.inner
17427     }
17428 }
17429 #[repr(C)]
17430 #[derive(Copy, Clone, Debug)]
17431 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>"]
17432 pub struct ImportSemaphoreWin32HandleInfoKHR {
17433     pub s_type: StructureType,
17434     pub p_next: *const c_void,
17435     pub semaphore: Semaphore,
17436     pub flags: SemaphoreImportFlags,
17437     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17438     pub handle: HANDLE,
17439     pub name: LPCWSTR,
17440 }
17441 impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR {
default() -> ImportSemaphoreWin32HandleInfoKHR17442     fn default() -> ImportSemaphoreWin32HandleInfoKHR {
17443         ImportSemaphoreWin32HandleInfoKHR {
17444             s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
17445             p_next: ::std::ptr::null(),
17446             semaphore: Semaphore::default(),
17447             flags: SemaphoreImportFlags::default(),
17448             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17449             handle: unsafe { ::std::mem::zeroed() },
17450             name: unsafe { ::std::mem::zeroed() },
17451         }
17452     }
17453 }
17454 impl ImportSemaphoreWin32HandleInfoKHR {
builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17455     pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17456         ImportSemaphoreWin32HandleInfoKHRBuilder {
17457             inner: ImportSemaphoreWin32HandleInfoKHR::default(),
17458             marker: ::std::marker::PhantomData,
17459         }
17460     }
17461 }
17462 #[repr(transparent)]
17463 pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17464     inner: ImportSemaphoreWin32HandleInfoKHR,
17465     marker: ::std::marker::PhantomData<&'a ()>,
17466 }
17467 pub unsafe trait ExtendsImportSemaphoreWin32HandleInfoKHR {}
17468 impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17469     type Target = ImportSemaphoreWin32HandleInfoKHR;
deref(&self) -> &Self::Target17470     fn deref(&self) -> &Self::Target {
17471         &self.inner
17472     }
17473 }
17474 impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17475     fn deref_mut(&mut self) -> &mut Self::Target {
17476         &mut self.inner
17477     }
17478 }
17479 impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
semaphore( mut self, semaphore: Semaphore, ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17480     pub fn semaphore(
17481         mut self,
17482         semaphore: Semaphore,
17483     ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17484         self.inner.semaphore = semaphore;
17485         self
17486     }
flags( mut self, flags: SemaphoreImportFlags, ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17487     pub fn flags(
17488         mut self,
17489         flags: SemaphoreImportFlags,
17490     ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17491         self.inner.flags = flags;
17492         self
17493     }
handle_type( mut self, handle_type: ExternalSemaphoreHandleTypeFlags, ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17494     pub fn handle_type(
17495         mut self,
17496         handle_type: ExternalSemaphoreHandleTypeFlags,
17497     ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17498         self.inner.handle_type = handle_type;
17499         self
17500     }
handle(mut self, handle: HANDLE) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17501     pub fn handle(mut self, handle: HANDLE) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17502         self.inner.handle = handle;
17503         self
17504     }
name(mut self, name: LPCWSTR) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17505     pub fn name(mut self, name: LPCWSTR) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17506         self.inner.name = name;
17507         self
17508     }
17509     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17510     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17511     #[doc = r" valid extension structs can be pushed into the chain."]
17512     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17513     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImportSemaphoreWin32HandleInfoKHR>( mut self, next: &'a mut T, ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a>17514     pub fn push_next<T: ExtendsImportSemaphoreWin32HandleInfoKHR>(
17515         mut self,
17516         next: &'a mut T,
17517     ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17518         unsafe {
17519             let next_ptr = next as *mut T as *mut BaseOutStructure;
17520             let last_next = ptr_chain_iter(next).last().unwrap();
17521             (*last_next).p_next = self.inner.p_next as _;
17522             self.inner.p_next = next_ptr as _;
17523         }
17524         self
17525     }
17526     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17527     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17528     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportSemaphoreWin32HandleInfoKHR17529     pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR {
17530         self.inner
17531     }
17532 }
17533 #[repr(C)]
17534 #[derive(Copy, Clone, Debug)]
17535 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>"]
17536 pub struct ExportSemaphoreWin32HandleInfoKHR {
17537     pub s_type: StructureType,
17538     pub p_next: *const c_void,
17539     pub p_attributes: *const SECURITY_ATTRIBUTES,
17540     pub dw_access: DWORD,
17541     pub name: LPCWSTR,
17542 }
17543 impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR {
default() -> ExportSemaphoreWin32HandleInfoKHR17544     fn default() -> ExportSemaphoreWin32HandleInfoKHR {
17545         ExportSemaphoreWin32HandleInfoKHR {
17546             s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
17547             p_next: ::std::ptr::null(),
17548             p_attributes: ::std::ptr::null(),
17549             dw_access: DWORD::default(),
17550             name: unsafe { ::std::mem::zeroed() },
17551         }
17552     }
17553 }
17554 impl ExportSemaphoreWin32HandleInfoKHR {
builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a>17555     pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17556         ExportSemaphoreWin32HandleInfoKHRBuilder {
17557             inner: ExportSemaphoreWin32HandleInfoKHR::default(),
17558             marker: ::std::marker::PhantomData,
17559         }
17560     }
17561 }
17562 #[repr(transparent)]
17563 pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17564     inner: ExportSemaphoreWin32HandleInfoKHR,
17565     marker: ::std::marker::PhantomData<&'a ()>,
17566 }
17567 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {}
17568 unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {}
17569 impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17570     type Target = ExportSemaphoreWin32HandleInfoKHR;
deref(&self) -> &Self::Target17571     fn deref(&self) -> &Self::Target {
17572         &self.inner
17573     }
17574 }
17575 impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17576     fn deref_mut(&mut self) -> &mut Self::Target {
17577         &mut self.inner
17578     }
17579 }
17580 impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
attributes( mut self, attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a>17581     pub fn attributes(
17582         mut self,
17583         attributes: &'a SECURITY_ATTRIBUTES,
17584     ) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17585         self.inner.p_attributes = attributes;
17586         self
17587     }
dw_access(mut self, dw_access: DWORD) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a>17588     pub fn dw_access(mut self, dw_access: DWORD) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17589         self.inner.dw_access = dw_access;
17590         self
17591     }
name(mut self, name: LPCWSTR) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a>17592     pub fn name(mut self, name: LPCWSTR) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
17593         self.inner.name = name;
17594         self
17595     }
17596     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17597     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17598     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportSemaphoreWin32HandleInfoKHR17599     pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR {
17600         self.inner
17601     }
17602 }
17603 #[repr(C)]
17604 #[derive(Copy, Clone, Debug)]
17605 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html>"]
17606 pub struct D3D12FenceSubmitInfoKHR {
17607     pub s_type: StructureType,
17608     pub p_next: *const c_void,
17609     pub wait_semaphore_values_count: u32,
17610     pub p_wait_semaphore_values: *const u64,
17611     pub signal_semaphore_values_count: u32,
17612     pub p_signal_semaphore_values: *const u64,
17613 }
17614 impl ::std::default::Default for D3D12FenceSubmitInfoKHR {
default() -> D3D12FenceSubmitInfoKHR17615     fn default() -> D3D12FenceSubmitInfoKHR {
17616         D3D12FenceSubmitInfoKHR {
17617             s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR,
17618             p_next: ::std::ptr::null(),
17619             wait_semaphore_values_count: u32::default(),
17620             p_wait_semaphore_values: ::std::ptr::null(),
17621             signal_semaphore_values_count: u32::default(),
17622             p_signal_semaphore_values: ::std::ptr::null(),
17623         }
17624     }
17625 }
17626 impl D3D12FenceSubmitInfoKHR {
builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a>17627     pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> {
17628         D3D12FenceSubmitInfoKHRBuilder {
17629             inner: D3D12FenceSubmitInfoKHR::default(),
17630             marker: ::std::marker::PhantomData,
17631         }
17632     }
17633 }
17634 #[repr(transparent)]
17635 pub struct D3D12FenceSubmitInfoKHRBuilder<'a> {
17636     inner: D3D12FenceSubmitInfoKHR,
17637     marker: ::std::marker::PhantomData<&'a ()>,
17638 }
17639 unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {}
17640 unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {}
17641 impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> {
17642     type Target = D3D12FenceSubmitInfoKHR;
deref(&self) -> &Self::Target17643     fn deref(&self) -> &Self::Target {
17644         &self.inner
17645     }
17646 }
17647 impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17648     fn deref_mut(&mut self) -> &mut Self::Target {
17649         &mut self.inner
17650     }
17651 }
17652 impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
wait_semaphore_values( mut self, wait_semaphore_values: &'a [u64], ) -> D3D12FenceSubmitInfoKHRBuilder<'a>17653     pub fn wait_semaphore_values(
17654         mut self,
17655         wait_semaphore_values: &'a [u64],
17656     ) -> D3D12FenceSubmitInfoKHRBuilder<'a> {
17657         self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _;
17658         self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
17659         self
17660     }
signal_semaphore_values( mut self, signal_semaphore_values: &'a [u64], ) -> D3D12FenceSubmitInfoKHRBuilder<'a>17661     pub fn signal_semaphore_values(
17662         mut self,
17663         signal_semaphore_values: &'a [u64],
17664     ) -> D3D12FenceSubmitInfoKHRBuilder<'a> {
17665         self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _;
17666         self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
17667         self
17668     }
17669     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17670     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17671     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> D3D12FenceSubmitInfoKHR17672     pub fn build(self) -> D3D12FenceSubmitInfoKHR {
17673         self.inner
17674     }
17675 }
17676 #[repr(C)]
17677 #[derive(Copy, Clone, Debug)]
17678 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>"]
17679 pub struct SemaphoreGetWin32HandleInfoKHR {
17680     pub s_type: StructureType,
17681     pub p_next: *const c_void,
17682     pub semaphore: Semaphore,
17683     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17684 }
17685 impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR {
default() -> SemaphoreGetWin32HandleInfoKHR17686     fn default() -> SemaphoreGetWin32HandleInfoKHR {
17687         SemaphoreGetWin32HandleInfoKHR {
17688             s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
17689             p_next: ::std::ptr::null(),
17690             semaphore: Semaphore::default(),
17691             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17692         }
17693     }
17694 }
17695 impl SemaphoreGetWin32HandleInfoKHR {
builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a>17696     pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17697         SemaphoreGetWin32HandleInfoKHRBuilder {
17698             inner: SemaphoreGetWin32HandleInfoKHR::default(),
17699             marker: ::std::marker::PhantomData,
17700         }
17701     }
17702 }
17703 #[repr(transparent)]
17704 pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17705     inner: SemaphoreGetWin32HandleInfoKHR,
17706     marker: ::std::marker::PhantomData<&'a ()>,
17707 }
17708 pub unsafe trait ExtendsSemaphoreGetWin32HandleInfoKHR {}
17709 impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17710     type Target = SemaphoreGetWin32HandleInfoKHR;
deref(&self) -> &Self::Target17711     fn deref(&self) -> &Self::Target {
17712         &self.inner
17713     }
17714 }
17715 impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17716     fn deref_mut(&mut self) -> &mut Self::Target {
17717         &mut self.inner
17718     }
17719 }
17720 impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a>17721     pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17722         self.inner.semaphore = semaphore;
17723         self
17724     }
handle_type( mut self, handle_type: ExternalSemaphoreHandleTypeFlags, ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a>17725     pub fn handle_type(
17726         mut self,
17727         handle_type: ExternalSemaphoreHandleTypeFlags,
17728     ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17729         self.inner.handle_type = handle_type;
17730         self
17731     }
17732     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17733     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17734     #[doc = r" valid extension structs can be pushed into the chain."]
17735     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17736     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSemaphoreGetWin32HandleInfoKHR>( mut self, next: &'a mut T, ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a>17737     pub fn push_next<T: ExtendsSemaphoreGetWin32HandleInfoKHR>(
17738         mut self,
17739         next: &'a mut T,
17740     ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
17741         unsafe {
17742             let next_ptr = next as *mut T as *mut BaseOutStructure;
17743             let last_next = ptr_chain_iter(next).last().unwrap();
17744             (*last_next).p_next = self.inner.p_next as _;
17745             self.inner.p_next = next_ptr as _;
17746         }
17747         self
17748     }
17749     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17750     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17751     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreGetWin32HandleInfoKHR17752     pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR {
17753         self.inner
17754     }
17755 }
17756 #[repr(C)]
17757 #[derive(Copy, Clone, Debug)]
17758 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportSemaphoreFdInfoKHR.html>"]
17759 pub struct ImportSemaphoreFdInfoKHR {
17760     pub s_type: StructureType,
17761     pub p_next: *const c_void,
17762     pub semaphore: Semaphore,
17763     pub flags: SemaphoreImportFlags,
17764     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17765     pub fd: c_int,
17766 }
17767 impl ::std::default::Default for ImportSemaphoreFdInfoKHR {
default() -> ImportSemaphoreFdInfoKHR17768     fn default() -> ImportSemaphoreFdInfoKHR {
17769         ImportSemaphoreFdInfoKHR {
17770             s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR,
17771             p_next: ::std::ptr::null(),
17772             semaphore: Semaphore::default(),
17773             flags: SemaphoreImportFlags::default(),
17774             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17775             fd: c_int::default(),
17776         }
17777     }
17778 }
17779 impl ImportSemaphoreFdInfoKHR {
builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a>17780     pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> {
17781         ImportSemaphoreFdInfoKHRBuilder {
17782             inner: ImportSemaphoreFdInfoKHR::default(),
17783             marker: ::std::marker::PhantomData,
17784         }
17785     }
17786 }
17787 #[repr(transparent)]
17788 pub struct ImportSemaphoreFdInfoKHRBuilder<'a> {
17789     inner: ImportSemaphoreFdInfoKHR,
17790     marker: ::std::marker::PhantomData<&'a ()>,
17791 }
17792 pub unsafe trait ExtendsImportSemaphoreFdInfoKHR {}
17793 impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> {
17794     type Target = ImportSemaphoreFdInfoKHR;
deref(&self) -> &Self::Target17795     fn deref(&self) -> &Self::Target {
17796         &self.inner
17797     }
17798 }
17799 impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17800     fn deref_mut(&mut self) -> &mut Self::Target {
17801         &mut self.inner
17802     }
17803 }
17804 impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
semaphore(mut self, semaphore: Semaphore) -> ImportSemaphoreFdInfoKHRBuilder<'a>17805     pub fn semaphore(mut self, semaphore: Semaphore) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
17806         self.inner.semaphore = semaphore;
17807         self
17808     }
flags(mut self, flags: SemaphoreImportFlags) -> ImportSemaphoreFdInfoKHRBuilder<'a>17809     pub fn flags(mut self, flags: SemaphoreImportFlags) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
17810         self.inner.flags = flags;
17811         self
17812     }
handle_type( mut self, handle_type: ExternalSemaphoreHandleTypeFlags, ) -> ImportSemaphoreFdInfoKHRBuilder<'a>17813     pub fn handle_type(
17814         mut self,
17815         handle_type: ExternalSemaphoreHandleTypeFlags,
17816     ) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
17817         self.inner.handle_type = handle_type;
17818         self
17819     }
fd(mut self, fd: c_int) -> ImportSemaphoreFdInfoKHRBuilder<'a>17820     pub fn fd(mut self, fd: c_int) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
17821         self.inner.fd = fd;
17822         self
17823     }
17824     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17825     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17826     #[doc = r" valid extension structs can be pushed into the chain."]
17827     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17828     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImportSemaphoreFdInfoKHR>( mut self, next: &'a mut T, ) -> ImportSemaphoreFdInfoKHRBuilder<'a>17829     pub fn push_next<T: ExtendsImportSemaphoreFdInfoKHR>(
17830         mut self,
17831         next: &'a mut T,
17832     ) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
17833         unsafe {
17834             let next_ptr = next as *mut T as *mut BaseOutStructure;
17835             let last_next = ptr_chain_iter(next).last().unwrap();
17836             (*last_next).p_next = self.inner.p_next as _;
17837             self.inner.p_next = next_ptr as _;
17838         }
17839         self
17840     }
17841     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17842     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17843     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportSemaphoreFdInfoKHR17844     pub fn build(self) -> ImportSemaphoreFdInfoKHR {
17845         self.inner
17846     }
17847 }
17848 #[repr(C)]
17849 #[derive(Copy, Clone, Debug)]
17850 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreGetFdInfoKHR.html>"]
17851 pub struct SemaphoreGetFdInfoKHR {
17852     pub s_type: StructureType,
17853     pub p_next: *const c_void,
17854     pub semaphore: Semaphore,
17855     pub handle_type: ExternalSemaphoreHandleTypeFlags,
17856 }
17857 impl ::std::default::Default for SemaphoreGetFdInfoKHR {
default() -> SemaphoreGetFdInfoKHR17858     fn default() -> SemaphoreGetFdInfoKHR {
17859         SemaphoreGetFdInfoKHR {
17860             s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR,
17861             p_next: ::std::ptr::null(),
17862             semaphore: Semaphore::default(),
17863             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
17864         }
17865     }
17866 }
17867 impl SemaphoreGetFdInfoKHR {
builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a>17868     pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> {
17869         SemaphoreGetFdInfoKHRBuilder {
17870             inner: SemaphoreGetFdInfoKHR::default(),
17871             marker: ::std::marker::PhantomData,
17872         }
17873     }
17874 }
17875 #[repr(transparent)]
17876 pub struct SemaphoreGetFdInfoKHRBuilder<'a> {
17877     inner: SemaphoreGetFdInfoKHR,
17878     marker: ::std::marker::PhantomData<&'a ()>,
17879 }
17880 pub unsafe trait ExtendsSemaphoreGetFdInfoKHR {}
17881 impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> {
17882     type Target = SemaphoreGetFdInfoKHR;
deref(&self) -> &Self::Target17883     fn deref(&self) -> &Self::Target {
17884         &self.inner
17885     }
17886 }
17887 impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17888     fn deref_mut(&mut self) -> &mut Self::Target {
17889         &mut self.inner
17890     }
17891 }
17892 impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetFdInfoKHRBuilder<'a>17893     pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetFdInfoKHRBuilder<'a> {
17894         self.inner.semaphore = semaphore;
17895         self
17896     }
handle_type( mut self, handle_type: ExternalSemaphoreHandleTypeFlags, ) -> SemaphoreGetFdInfoKHRBuilder<'a>17897     pub fn handle_type(
17898         mut self,
17899         handle_type: ExternalSemaphoreHandleTypeFlags,
17900     ) -> SemaphoreGetFdInfoKHRBuilder<'a> {
17901         self.inner.handle_type = handle_type;
17902         self
17903     }
17904     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17905     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17906     #[doc = r" valid extension structs can be pushed into the chain."]
17907     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17908     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSemaphoreGetFdInfoKHR>( mut self, next: &'a mut T, ) -> SemaphoreGetFdInfoKHRBuilder<'a>17909     pub fn push_next<T: ExtendsSemaphoreGetFdInfoKHR>(
17910         mut self,
17911         next: &'a mut T,
17912     ) -> SemaphoreGetFdInfoKHRBuilder<'a> {
17913         unsafe {
17914             let next_ptr = next as *mut T as *mut BaseOutStructure;
17915             let last_next = ptr_chain_iter(next).last().unwrap();
17916             (*last_next).p_next = self.inner.p_next as _;
17917             self.inner.p_next = next_ptr as _;
17918         }
17919         self
17920     }
17921     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17922     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17923     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreGetFdInfoKHR17924     pub fn build(self) -> SemaphoreGetFdInfoKHR {
17925         self.inner
17926     }
17927 }
17928 #[repr(C)]
17929 #[derive(Copy, Clone, Debug)]
17930 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html>"]
17931 pub struct PhysicalDeviceExternalFenceInfo {
17932     pub s_type: StructureType,
17933     pub p_next: *const c_void,
17934     pub handle_type: ExternalFenceHandleTypeFlags,
17935 }
17936 impl ::std::default::Default for PhysicalDeviceExternalFenceInfo {
default() -> PhysicalDeviceExternalFenceInfo17937     fn default() -> PhysicalDeviceExternalFenceInfo {
17938         PhysicalDeviceExternalFenceInfo {
17939             s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
17940             p_next: ::std::ptr::null(),
17941             handle_type: ExternalFenceHandleTypeFlags::default(),
17942         }
17943     }
17944 }
17945 impl PhysicalDeviceExternalFenceInfo {
builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a>17946     pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
17947         PhysicalDeviceExternalFenceInfoBuilder {
17948             inner: PhysicalDeviceExternalFenceInfo::default(),
17949             marker: ::std::marker::PhantomData,
17950         }
17951     }
17952 }
17953 #[repr(transparent)]
17954 pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> {
17955     inner: PhysicalDeviceExternalFenceInfo,
17956     marker: ::std::marker::PhantomData<&'a ()>,
17957 }
17958 pub unsafe trait ExtendsPhysicalDeviceExternalFenceInfo {}
17959 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> {
17960     type Target = PhysicalDeviceExternalFenceInfo;
deref(&self) -> &Self::Target17961     fn deref(&self) -> &Self::Target {
17962         &self.inner
17963     }
17964 }
17965 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target17966     fn deref_mut(&mut self) -> &mut Self::Target {
17967         &mut self.inner
17968     }
17969 }
17970 impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
handle_type( mut self, handle_type: ExternalFenceHandleTypeFlags, ) -> PhysicalDeviceExternalFenceInfoBuilder<'a>17971     pub fn handle_type(
17972         mut self,
17973         handle_type: ExternalFenceHandleTypeFlags,
17974     ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
17975         self.inner.handle_type = handle_type;
17976         self
17977     }
17978     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
17979     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
17980     #[doc = r" valid extension structs can be pushed into the chain."]
17981     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
17982     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceExternalFenceInfo>( mut self, next: &'a mut T, ) -> PhysicalDeviceExternalFenceInfoBuilder<'a>17983     pub fn push_next<T: ExtendsPhysicalDeviceExternalFenceInfo>(
17984         mut self,
17985         next: &'a mut T,
17986     ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
17987         unsafe {
17988             let next_ptr = next as *mut T as *mut BaseOutStructure;
17989             let last_next = ptr_chain_iter(next).last().unwrap();
17990             (*last_next).p_next = self.inner.p_next as _;
17991             self.inner.p_next = next_ptr as _;
17992         }
17993         self
17994     }
17995     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
17996     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
17997     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalFenceInfo17998     pub fn build(self) -> PhysicalDeviceExternalFenceInfo {
17999         self.inner
18000     }
18001 }
18002 #[repr(C)]
18003 #[derive(Copy, Clone, Debug)]
18004 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceProperties.html>"]
18005 pub struct ExternalFenceProperties {
18006     pub s_type: StructureType,
18007     pub p_next: *mut c_void,
18008     pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
18009     pub compatible_handle_types: ExternalFenceHandleTypeFlags,
18010     pub external_fence_features: ExternalFenceFeatureFlags,
18011 }
18012 impl ::std::default::Default for ExternalFenceProperties {
default() -> ExternalFenceProperties18013     fn default() -> ExternalFenceProperties {
18014         ExternalFenceProperties {
18015             s_type: StructureType::EXTERNAL_FENCE_PROPERTIES,
18016             p_next: ::std::ptr::null_mut(),
18017             export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(),
18018             compatible_handle_types: ExternalFenceHandleTypeFlags::default(),
18019             external_fence_features: ExternalFenceFeatureFlags::default(),
18020         }
18021     }
18022 }
18023 impl ExternalFenceProperties {
builder<'a>() -> ExternalFencePropertiesBuilder<'a>18024     pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> {
18025         ExternalFencePropertiesBuilder {
18026             inner: ExternalFenceProperties::default(),
18027             marker: ::std::marker::PhantomData,
18028         }
18029     }
18030 }
18031 #[repr(transparent)]
18032 pub struct ExternalFencePropertiesBuilder<'a> {
18033     inner: ExternalFenceProperties,
18034     marker: ::std::marker::PhantomData<&'a ()>,
18035 }
18036 pub unsafe trait ExtendsExternalFenceProperties {}
18037 impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> {
18038     type Target = ExternalFenceProperties;
deref(&self) -> &Self::Target18039     fn deref(&self) -> &Self::Target {
18040         &self.inner
18041     }
18042 }
18043 impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18044     fn deref_mut(&mut self) -> &mut Self::Target {
18045         &mut self.inner
18046     }
18047 }
18048 impl<'a> ExternalFencePropertiesBuilder<'a> {
export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalFenceHandleTypeFlags, ) -> ExternalFencePropertiesBuilder<'a>18049     pub fn export_from_imported_handle_types(
18050         mut self,
18051         export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
18052     ) -> ExternalFencePropertiesBuilder<'a> {
18053         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
18054         self
18055     }
compatible_handle_types( mut self, compatible_handle_types: ExternalFenceHandleTypeFlags, ) -> ExternalFencePropertiesBuilder<'a>18056     pub fn compatible_handle_types(
18057         mut self,
18058         compatible_handle_types: ExternalFenceHandleTypeFlags,
18059     ) -> ExternalFencePropertiesBuilder<'a> {
18060         self.inner.compatible_handle_types = compatible_handle_types;
18061         self
18062     }
external_fence_features( mut self, external_fence_features: ExternalFenceFeatureFlags, ) -> ExternalFencePropertiesBuilder<'a>18063     pub fn external_fence_features(
18064         mut self,
18065         external_fence_features: ExternalFenceFeatureFlags,
18066     ) -> ExternalFencePropertiesBuilder<'a> {
18067         self.inner.external_fence_features = external_fence_features;
18068         self
18069     }
18070     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
18071     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
18072     #[doc = r" valid extension structs can be pushed into the chain."]
18073     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
18074     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsExternalFenceProperties>( mut self, next: &'a mut T, ) -> ExternalFencePropertiesBuilder<'a>18075     pub fn push_next<T: ExtendsExternalFenceProperties>(
18076         mut self,
18077         next: &'a mut T,
18078     ) -> ExternalFencePropertiesBuilder<'a> {
18079         unsafe {
18080             let next_ptr = next as *mut T as *mut BaseOutStructure;
18081             let last_next = ptr_chain_iter(next).last().unwrap();
18082             (*last_next).p_next = self.inner.p_next as _;
18083             self.inner.p_next = next_ptr as _;
18084         }
18085         self
18086     }
18087     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18088     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18089     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalFenceProperties18090     pub fn build(self) -> ExternalFenceProperties {
18091         self.inner
18092     }
18093 }
18094 #[repr(C)]
18095 #[derive(Copy, Clone, Debug)]
18096 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportFenceCreateInfo.html>"]
18097 pub struct ExportFenceCreateInfo {
18098     pub s_type: StructureType,
18099     pub p_next: *const c_void,
18100     pub handle_types: ExternalFenceHandleTypeFlags,
18101 }
18102 impl ::std::default::Default for ExportFenceCreateInfo {
default() -> ExportFenceCreateInfo18103     fn default() -> ExportFenceCreateInfo {
18104         ExportFenceCreateInfo {
18105             s_type: StructureType::EXPORT_FENCE_CREATE_INFO,
18106             p_next: ::std::ptr::null(),
18107             handle_types: ExternalFenceHandleTypeFlags::default(),
18108         }
18109     }
18110 }
18111 impl ExportFenceCreateInfo {
builder<'a>() -> ExportFenceCreateInfoBuilder<'a>18112     pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> {
18113         ExportFenceCreateInfoBuilder {
18114             inner: ExportFenceCreateInfo::default(),
18115             marker: ::std::marker::PhantomData,
18116         }
18117     }
18118 }
18119 #[repr(transparent)]
18120 pub struct ExportFenceCreateInfoBuilder<'a> {
18121     inner: ExportFenceCreateInfo,
18122     marker: ::std::marker::PhantomData<&'a ()>,
18123 }
18124 unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {}
18125 unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {}
18126 impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> {
18127     type Target = ExportFenceCreateInfo;
deref(&self) -> &Self::Target18128     fn deref(&self) -> &Self::Target {
18129         &self.inner
18130     }
18131 }
18132 impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18133     fn deref_mut(&mut self) -> &mut Self::Target {
18134         &mut self.inner
18135     }
18136 }
18137 impl<'a> ExportFenceCreateInfoBuilder<'a> {
handle_types( mut self, handle_types: ExternalFenceHandleTypeFlags, ) -> ExportFenceCreateInfoBuilder<'a>18138     pub fn handle_types(
18139         mut self,
18140         handle_types: ExternalFenceHandleTypeFlags,
18141     ) -> ExportFenceCreateInfoBuilder<'a> {
18142         self.inner.handle_types = handle_types;
18143         self
18144     }
18145     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18146     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18147     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportFenceCreateInfo18148     pub fn build(self) -> ExportFenceCreateInfo {
18149         self.inner
18150     }
18151 }
18152 #[repr(C)]
18153 #[derive(Copy, Clone, Debug)]
18154 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportFenceWin32HandleInfoKHR.html>"]
18155 pub struct ImportFenceWin32HandleInfoKHR {
18156     pub s_type: StructureType,
18157     pub p_next: *const c_void,
18158     pub fence: Fence,
18159     pub flags: FenceImportFlags,
18160     pub handle_type: ExternalFenceHandleTypeFlags,
18161     pub handle: HANDLE,
18162     pub name: LPCWSTR,
18163 }
18164 impl ::std::default::Default for ImportFenceWin32HandleInfoKHR {
default() -> ImportFenceWin32HandleInfoKHR18165     fn default() -> ImportFenceWin32HandleInfoKHR {
18166         ImportFenceWin32HandleInfoKHR {
18167             s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
18168             p_next: ::std::ptr::null(),
18169             fence: Fence::default(),
18170             flags: FenceImportFlags::default(),
18171             handle_type: ExternalFenceHandleTypeFlags::default(),
18172             handle: unsafe { ::std::mem::zeroed() },
18173             name: unsafe { ::std::mem::zeroed() },
18174         }
18175     }
18176 }
18177 impl ImportFenceWin32HandleInfoKHR {
builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a>18178     pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18179         ImportFenceWin32HandleInfoKHRBuilder {
18180             inner: ImportFenceWin32HandleInfoKHR::default(),
18181             marker: ::std::marker::PhantomData,
18182         }
18183     }
18184 }
18185 #[repr(transparent)]
18186 pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> {
18187     inner: ImportFenceWin32HandleInfoKHR,
18188     marker: ::std::marker::PhantomData<&'a ()>,
18189 }
18190 pub unsafe trait ExtendsImportFenceWin32HandleInfoKHR {}
18191 impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> {
18192     type Target = ImportFenceWin32HandleInfoKHR;
deref(&self) -> &Self::Target18193     fn deref(&self) -> &Self::Target {
18194         &self.inner
18195     }
18196 }
18197 impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18198     fn deref_mut(&mut self) -> &mut Self::Target {
18199         &mut self.inner
18200     }
18201 }
18202 impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
fence(mut self, fence: Fence) -> ImportFenceWin32HandleInfoKHRBuilder<'a>18203     pub fn fence(mut self, fence: Fence) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18204         self.inner.fence = fence;
18205         self
18206     }
flags(mut self, flags: FenceImportFlags) -> ImportFenceWin32HandleInfoKHRBuilder<'a>18207     pub fn flags(mut self, flags: FenceImportFlags) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18208         self.inner.flags = flags;
18209         self
18210     }
handle_type( mut self, handle_type: ExternalFenceHandleTypeFlags, ) -> ImportFenceWin32HandleInfoKHRBuilder<'a>18211     pub fn handle_type(
18212         mut self,
18213         handle_type: ExternalFenceHandleTypeFlags,
18214     ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18215         self.inner.handle_type = handle_type;
18216         self
18217     }
handle(mut self, handle: HANDLE) -> ImportFenceWin32HandleInfoKHRBuilder<'a>18218     pub fn handle(mut self, handle: HANDLE) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18219         self.inner.handle = handle;
18220         self
18221     }
name(mut self, name: LPCWSTR) -> ImportFenceWin32HandleInfoKHRBuilder<'a>18222     pub fn name(mut self, name: LPCWSTR) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18223         self.inner.name = name;
18224         self
18225     }
18226     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
18227     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
18228     #[doc = r" valid extension structs can be pushed into the chain."]
18229     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
18230     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImportFenceWin32HandleInfoKHR>( mut self, next: &'a mut T, ) -> ImportFenceWin32HandleInfoKHRBuilder<'a>18231     pub fn push_next<T: ExtendsImportFenceWin32HandleInfoKHR>(
18232         mut self,
18233         next: &'a mut T,
18234     ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
18235         unsafe {
18236             let next_ptr = next as *mut T as *mut BaseOutStructure;
18237             let last_next = ptr_chain_iter(next).last().unwrap();
18238             (*last_next).p_next = self.inner.p_next as _;
18239             self.inner.p_next = next_ptr as _;
18240         }
18241         self
18242     }
18243     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18244     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18245     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportFenceWin32HandleInfoKHR18246     pub fn build(self) -> ImportFenceWin32HandleInfoKHR {
18247         self.inner
18248     }
18249 }
18250 #[repr(C)]
18251 #[derive(Copy, Clone, Debug)]
18252 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html>"]
18253 pub struct ExportFenceWin32HandleInfoKHR {
18254     pub s_type: StructureType,
18255     pub p_next: *const c_void,
18256     pub p_attributes: *const SECURITY_ATTRIBUTES,
18257     pub dw_access: DWORD,
18258     pub name: LPCWSTR,
18259 }
18260 impl ::std::default::Default for ExportFenceWin32HandleInfoKHR {
default() -> ExportFenceWin32HandleInfoKHR18261     fn default() -> ExportFenceWin32HandleInfoKHR {
18262         ExportFenceWin32HandleInfoKHR {
18263             s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
18264             p_next: ::std::ptr::null(),
18265             p_attributes: ::std::ptr::null(),
18266             dw_access: DWORD::default(),
18267             name: unsafe { ::std::mem::zeroed() },
18268         }
18269     }
18270 }
18271 impl ExportFenceWin32HandleInfoKHR {
builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a>18272     pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
18273         ExportFenceWin32HandleInfoKHRBuilder {
18274             inner: ExportFenceWin32HandleInfoKHR::default(),
18275             marker: ::std::marker::PhantomData,
18276         }
18277     }
18278 }
18279 #[repr(transparent)]
18280 pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> {
18281     inner: ExportFenceWin32HandleInfoKHR,
18282     marker: ::std::marker::PhantomData<&'a ()>,
18283 }
18284 unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {}
18285 unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {}
18286 impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> {
18287     type Target = ExportFenceWin32HandleInfoKHR;
deref(&self) -> &Self::Target18288     fn deref(&self) -> &Self::Target {
18289         &self.inner
18290     }
18291 }
18292 impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18293     fn deref_mut(&mut self) -> &mut Self::Target {
18294         &mut self.inner
18295     }
18296 }
18297 impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
attributes( mut self, attributes: &'a SECURITY_ATTRIBUTES, ) -> ExportFenceWin32HandleInfoKHRBuilder<'a>18298     pub fn attributes(
18299         mut self,
18300         attributes: &'a SECURITY_ATTRIBUTES,
18301     ) -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
18302         self.inner.p_attributes = attributes;
18303         self
18304     }
dw_access(mut self, dw_access: DWORD) -> ExportFenceWin32HandleInfoKHRBuilder<'a>18305     pub fn dw_access(mut self, dw_access: DWORD) -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
18306         self.inner.dw_access = dw_access;
18307         self
18308     }
name(mut self, name: LPCWSTR) -> ExportFenceWin32HandleInfoKHRBuilder<'a>18309     pub fn name(mut self, name: LPCWSTR) -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
18310         self.inner.name = name;
18311         self
18312     }
18313     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18314     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18315     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExportFenceWin32HandleInfoKHR18316     pub fn build(self) -> ExportFenceWin32HandleInfoKHR {
18317         self.inner
18318     }
18319 }
18320 #[repr(C)]
18321 #[derive(Copy, Clone, Debug)]
18322 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html>"]
18323 pub struct FenceGetWin32HandleInfoKHR {
18324     pub s_type: StructureType,
18325     pub p_next: *const c_void,
18326     pub fence: Fence,
18327     pub handle_type: ExternalFenceHandleTypeFlags,
18328 }
18329 impl ::std::default::Default for FenceGetWin32HandleInfoKHR {
default() -> FenceGetWin32HandleInfoKHR18330     fn default() -> FenceGetWin32HandleInfoKHR {
18331         FenceGetWin32HandleInfoKHR {
18332             s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR,
18333             p_next: ::std::ptr::null(),
18334             fence: Fence::default(),
18335             handle_type: ExternalFenceHandleTypeFlags::default(),
18336         }
18337     }
18338 }
18339 impl FenceGetWin32HandleInfoKHR {
builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a>18340     pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> {
18341         FenceGetWin32HandleInfoKHRBuilder {
18342             inner: FenceGetWin32HandleInfoKHR::default(),
18343             marker: ::std::marker::PhantomData,
18344         }
18345     }
18346 }
18347 #[repr(transparent)]
18348 pub struct FenceGetWin32HandleInfoKHRBuilder<'a> {
18349     inner: FenceGetWin32HandleInfoKHR,
18350     marker: ::std::marker::PhantomData<&'a ()>,
18351 }
18352 pub unsafe trait ExtendsFenceGetWin32HandleInfoKHR {}
18353 impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> {
18354     type Target = FenceGetWin32HandleInfoKHR;
deref(&self) -> &Self::Target18355     fn deref(&self) -> &Self::Target {
18356         &self.inner
18357     }
18358 }
18359 impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18360     fn deref_mut(&mut self) -> &mut Self::Target {
18361         &mut self.inner
18362     }
18363 }
18364 impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
fence(mut self, fence: Fence) -> FenceGetWin32HandleInfoKHRBuilder<'a>18365     pub fn fence(mut self, fence: Fence) -> FenceGetWin32HandleInfoKHRBuilder<'a> {
18366         self.inner.fence = fence;
18367         self
18368     }
handle_type( mut self, handle_type: ExternalFenceHandleTypeFlags, ) -> FenceGetWin32HandleInfoKHRBuilder<'a>18369     pub fn handle_type(
18370         mut self,
18371         handle_type: ExternalFenceHandleTypeFlags,
18372     ) -> FenceGetWin32HandleInfoKHRBuilder<'a> {
18373         self.inner.handle_type = handle_type;
18374         self
18375     }
18376     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
18377     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
18378     #[doc = r" valid extension structs can be pushed into the chain."]
18379     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
18380     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFenceGetWin32HandleInfoKHR>( mut self, next: &'a mut T, ) -> FenceGetWin32HandleInfoKHRBuilder<'a>18381     pub fn push_next<T: ExtendsFenceGetWin32HandleInfoKHR>(
18382         mut self,
18383         next: &'a mut T,
18384     ) -> FenceGetWin32HandleInfoKHRBuilder<'a> {
18385         unsafe {
18386             let next_ptr = next as *mut T as *mut BaseOutStructure;
18387             let last_next = ptr_chain_iter(next).last().unwrap();
18388             (*last_next).p_next = self.inner.p_next as _;
18389             self.inner.p_next = next_ptr as _;
18390         }
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."]
build(self) -> FenceGetWin32HandleInfoKHR18396     pub fn build(self) -> FenceGetWin32HandleInfoKHR {
18397         self.inner
18398     }
18399 }
18400 #[repr(C)]
18401 #[derive(Copy, Clone, Debug)]
18402 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportFenceFdInfoKHR.html>"]
18403 pub struct ImportFenceFdInfoKHR {
18404     pub s_type: StructureType,
18405     pub p_next: *const c_void,
18406     pub fence: Fence,
18407     pub flags: FenceImportFlags,
18408     pub handle_type: ExternalFenceHandleTypeFlags,
18409     pub fd: c_int,
18410 }
18411 impl ::std::default::Default for ImportFenceFdInfoKHR {
default() -> ImportFenceFdInfoKHR18412     fn default() -> ImportFenceFdInfoKHR {
18413         ImportFenceFdInfoKHR {
18414             s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR,
18415             p_next: ::std::ptr::null(),
18416             fence: Fence::default(),
18417             flags: FenceImportFlags::default(),
18418             handle_type: ExternalFenceHandleTypeFlags::default(),
18419             fd: c_int::default(),
18420         }
18421     }
18422 }
18423 impl ImportFenceFdInfoKHR {
builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a>18424     pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> {
18425         ImportFenceFdInfoKHRBuilder {
18426             inner: ImportFenceFdInfoKHR::default(),
18427             marker: ::std::marker::PhantomData,
18428         }
18429     }
18430 }
18431 #[repr(transparent)]
18432 pub struct ImportFenceFdInfoKHRBuilder<'a> {
18433     inner: ImportFenceFdInfoKHR,
18434     marker: ::std::marker::PhantomData<&'a ()>,
18435 }
18436 pub unsafe trait ExtendsImportFenceFdInfoKHR {}
18437 impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> {
18438     type Target = ImportFenceFdInfoKHR;
deref(&self) -> &Self::Target18439     fn deref(&self) -> &Self::Target {
18440         &self.inner
18441     }
18442 }
18443 impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18444     fn deref_mut(&mut self) -> &mut Self::Target {
18445         &mut self.inner
18446     }
18447 }
18448 impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
fence(mut self, fence: Fence) -> ImportFenceFdInfoKHRBuilder<'a>18449     pub fn fence(mut self, fence: Fence) -> ImportFenceFdInfoKHRBuilder<'a> {
18450         self.inner.fence = fence;
18451         self
18452     }
flags(mut self, flags: FenceImportFlags) -> ImportFenceFdInfoKHRBuilder<'a>18453     pub fn flags(mut self, flags: FenceImportFlags) -> ImportFenceFdInfoKHRBuilder<'a> {
18454         self.inner.flags = flags;
18455         self
18456     }
handle_type( mut self, handle_type: ExternalFenceHandleTypeFlags, ) -> ImportFenceFdInfoKHRBuilder<'a>18457     pub fn handle_type(
18458         mut self,
18459         handle_type: ExternalFenceHandleTypeFlags,
18460     ) -> ImportFenceFdInfoKHRBuilder<'a> {
18461         self.inner.handle_type = handle_type;
18462         self
18463     }
fd(mut self, fd: c_int) -> ImportFenceFdInfoKHRBuilder<'a>18464     pub fn fd(mut self, fd: c_int) -> ImportFenceFdInfoKHRBuilder<'a> {
18465         self.inner.fd = fd;
18466         self
18467     }
18468     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
18469     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
18470     #[doc = r" valid extension structs can be pushed into the chain."]
18471     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
18472     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImportFenceFdInfoKHR>( mut self, next: &'a mut T, ) -> ImportFenceFdInfoKHRBuilder<'a>18473     pub fn push_next<T: ExtendsImportFenceFdInfoKHR>(
18474         mut self,
18475         next: &'a mut T,
18476     ) -> ImportFenceFdInfoKHRBuilder<'a> {
18477         unsafe {
18478             let next_ptr = next as *mut T as *mut BaseOutStructure;
18479             let last_next = ptr_chain_iter(next).last().unwrap();
18480             (*last_next).p_next = self.inner.p_next as _;
18481             self.inner.p_next = next_ptr as _;
18482         }
18483         self
18484     }
18485     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18486     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18487     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportFenceFdInfoKHR18488     pub fn build(self) -> ImportFenceFdInfoKHR {
18489         self.inner
18490     }
18491 }
18492 #[repr(C)]
18493 #[derive(Copy, Clone, Debug)]
18494 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceGetFdInfoKHR.html>"]
18495 pub struct FenceGetFdInfoKHR {
18496     pub s_type: StructureType,
18497     pub p_next: *const c_void,
18498     pub fence: Fence,
18499     pub handle_type: ExternalFenceHandleTypeFlags,
18500 }
18501 impl ::std::default::Default for FenceGetFdInfoKHR {
default() -> FenceGetFdInfoKHR18502     fn default() -> FenceGetFdInfoKHR {
18503         FenceGetFdInfoKHR {
18504             s_type: StructureType::FENCE_GET_FD_INFO_KHR,
18505             p_next: ::std::ptr::null(),
18506             fence: Fence::default(),
18507             handle_type: ExternalFenceHandleTypeFlags::default(),
18508         }
18509     }
18510 }
18511 impl FenceGetFdInfoKHR {
builder<'a>() -> FenceGetFdInfoKHRBuilder<'a>18512     pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> {
18513         FenceGetFdInfoKHRBuilder {
18514             inner: FenceGetFdInfoKHR::default(),
18515             marker: ::std::marker::PhantomData,
18516         }
18517     }
18518 }
18519 #[repr(transparent)]
18520 pub struct FenceGetFdInfoKHRBuilder<'a> {
18521     inner: FenceGetFdInfoKHR,
18522     marker: ::std::marker::PhantomData<&'a ()>,
18523 }
18524 pub unsafe trait ExtendsFenceGetFdInfoKHR {}
18525 impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> {
18526     type Target = FenceGetFdInfoKHR;
deref(&self) -> &Self::Target18527     fn deref(&self) -> &Self::Target {
18528         &self.inner
18529     }
18530 }
18531 impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18532     fn deref_mut(&mut self) -> &mut Self::Target {
18533         &mut self.inner
18534     }
18535 }
18536 impl<'a> FenceGetFdInfoKHRBuilder<'a> {
fence(mut self, fence: Fence) -> FenceGetFdInfoKHRBuilder<'a>18537     pub fn fence(mut self, fence: Fence) -> FenceGetFdInfoKHRBuilder<'a> {
18538         self.inner.fence = fence;
18539         self
18540     }
handle_type( mut self, handle_type: ExternalFenceHandleTypeFlags, ) -> FenceGetFdInfoKHRBuilder<'a>18541     pub fn handle_type(
18542         mut self,
18543         handle_type: ExternalFenceHandleTypeFlags,
18544     ) -> FenceGetFdInfoKHRBuilder<'a> {
18545         self.inner.handle_type = handle_type;
18546         self
18547     }
18548     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
18549     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
18550     #[doc = r" valid extension structs can be pushed into the chain."]
18551     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
18552     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFenceGetFdInfoKHR>( mut self, next: &'a mut T, ) -> FenceGetFdInfoKHRBuilder<'a>18553     pub fn push_next<T: ExtendsFenceGetFdInfoKHR>(
18554         mut self,
18555         next: &'a mut T,
18556     ) -> FenceGetFdInfoKHRBuilder<'a> {
18557         unsafe {
18558             let next_ptr = next as *mut T as *mut BaseOutStructure;
18559             let last_next = ptr_chain_iter(next).last().unwrap();
18560             (*last_next).p_next = self.inner.p_next as _;
18561             self.inner.p_next = next_ptr as _;
18562         }
18563         self
18564     }
18565     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18566     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18567     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FenceGetFdInfoKHR18568     pub fn build(self) -> FenceGetFdInfoKHR {
18569         self.inner
18570     }
18571 }
18572 #[repr(C)]
18573 #[derive(Copy, Clone, Debug)]
18574 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html>"]
18575 pub struct PhysicalDeviceMultiviewFeatures {
18576     pub s_type: StructureType,
18577     pub p_next: *mut c_void,
18578     pub multiview: Bool32,
18579     pub multiview_geometry_shader: Bool32,
18580     pub multiview_tessellation_shader: Bool32,
18581 }
18582 impl ::std::default::Default for PhysicalDeviceMultiviewFeatures {
default() -> PhysicalDeviceMultiviewFeatures18583     fn default() -> PhysicalDeviceMultiviewFeatures {
18584         PhysicalDeviceMultiviewFeatures {
18585             s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
18586             p_next: ::std::ptr::null_mut(),
18587             multiview: Bool32::default(),
18588             multiview_geometry_shader: Bool32::default(),
18589             multiview_tessellation_shader: Bool32::default(),
18590         }
18591     }
18592 }
18593 impl PhysicalDeviceMultiviewFeatures {
builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a>18594     pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18595         PhysicalDeviceMultiviewFeaturesBuilder {
18596             inner: PhysicalDeviceMultiviewFeatures::default(),
18597             marker: ::std::marker::PhantomData,
18598         }
18599     }
18600 }
18601 #[repr(transparent)]
18602 pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18603     inner: PhysicalDeviceMultiviewFeatures,
18604     marker: ::std::marker::PhantomData<&'a ()>,
18605 }
18606 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
18607 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {}
18608 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18609     type Target = PhysicalDeviceMultiviewFeatures;
deref(&self) -> &Self::Target18610     fn deref(&self) -> &Self::Target {
18611         &self.inner
18612     }
18613 }
18614 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18615     fn deref_mut(&mut self) -> &mut Self::Target {
18616         &mut self.inner
18617     }
18618 }
18619 impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
multiview(mut self, multiview: bool) -> PhysicalDeviceMultiviewFeaturesBuilder<'a>18620     pub fn multiview(mut self, multiview: bool) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18621         self.inner.multiview = multiview.into();
18622         self
18623     }
multiview_geometry_shader( mut self, multiview_geometry_shader: bool, ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a>18624     pub fn multiview_geometry_shader(
18625         mut self,
18626         multiview_geometry_shader: bool,
18627     ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18628         self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
18629         self
18630     }
multiview_tessellation_shader( mut self, multiview_tessellation_shader: bool, ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a>18631     pub fn multiview_tessellation_shader(
18632         mut self,
18633         multiview_tessellation_shader: bool,
18634     ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
18635         self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
18636         self
18637     }
18638     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18639     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18640     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewFeatures18641     pub fn build(self) -> PhysicalDeviceMultiviewFeatures {
18642         self.inner
18643     }
18644 }
18645 #[repr(C)]
18646 #[derive(Copy, Clone, Debug)]
18647 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html>"]
18648 pub struct PhysicalDeviceMultiviewProperties {
18649     pub s_type: StructureType,
18650     pub p_next: *mut c_void,
18651     pub max_multiview_view_count: u32,
18652     pub max_multiview_instance_index: u32,
18653 }
18654 impl ::std::default::Default for PhysicalDeviceMultiviewProperties {
default() -> PhysicalDeviceMultiviewProperties18655     fn default() -> PhysicalDeviceMultiviewProperties {
18656         PhysicalDeviceMultiviewProperties {
18657             s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
18658             p_next: ::std::ptr::null_mut(),
18659             max_multiview_view_count: u32::default(),
18660             max_multiview_instance_index: u32::default(),
18661         }
18662     }
18663 }
18664 impl PhysicalDeviceMultiviewProperties {
builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a>18665     pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18666         PhysicalDeviceMultiviewPropertiesBuilder {
18667             inner: PhysicalDeviceMultiviewProperties::default(),
18668             marker: ::std::marker::PhantomData,
18669         }
18670     }
18671 }
18672 #[repr(transparent)]
18673 pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18674     inner: PhysicalDeviceMultiviewProperties,
18675     marker: ::std::marker::PhantomData<&'a ()>,
18676 }
18677 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {}
18678 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {}
18679 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18680     type Target = PhysicalDeviceMultiviewProperties;
deref(&self) -> &Self::Target18681     fn deref(&self) -> &Self::Target {
18682         &self.inner
18683     }
18684 }
18685 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18686     fn deref_mut(&mut self) -> &mut Self::Target {
18687         &mut self.inner
18688     }
18689 }
18690 impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
max_multiview_view_count( mut self, max_multiview_view_count: u32, ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a>18691     pub fn max_multiview_view_count(
18692         mut self,
18693         max_multiview_view_count: u32,
18694     ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18695         self.inner.max_multiview_view_count = max_multiview_view_count;
18696         self
18697     }
max_multiview_instance_index( mut self, max_multiview_instance_index: u32, ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a>18698     pub fn max_multiview_instance_index(
18699         mut self,
18700         max_multiview_instance_index: u32,
18701     ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
18702         self.inner.max_multiview_instance_index = max_multiview_instance_index;
18703         self
18704     }
18705     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18706     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18707     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewProperties18708     pub fn build(self) -> PhysicalDeviceMultiviewProperties {
18709         self.inner
18710     }
18711 }
18712 #[repr(C)]
18713 #[derive(Copy, Clone, Debug)]
18714 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassMultiviewCreateInfo.html>"]
18715 pub struct RenderPassMultiviewCreateInfo {
18716     pub s_type: StructureType,
18717     pub p_next: *const c_void,
18718     pub subpass_count: u32,
18719     pub p_view_masks: *const u32,
18720     pub dependency_count: u32,
18721     pub p_view_offsets: *const i32,
18722     pub correlation_mask_count: u32,
18723     pub p_correlation_masks: *const u32,
18724 }
18725 impl ::std::default::Default for RenderPassMultiviewCreateInfo {
default() -> RenderPassMultiviewCreateInfo18726     fn default() -> RenderPassMultiviewCreateInfo {
18727         RenderPassMultiviewCreateInfo {
18728             s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO,
18729             p_next: ::std::ptr::null(),
18730             subpass_count: u32::default(),
18731             p_view_masks: ::std::ptr::null(),
18732             dependency_count: u32::default(),
18733             p_view_offsets: ::std::ptr::null(),
18734             correlation_mask_count: u32::default(),
18735             p_correlation_masks: ::std::ptr::null(),
18736         }
18737     }
18738 }
18739 impl RenderPassMultiviewCreateInfo {
builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a>18740     pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> {
18741         RenderPassMultiviewCreateInfoBuilder {
18742             inner: RenderPassMultiviewCreateInfo::default(),
18743             marker: ::std::marker::PhantomData,
18744         }
18745     }
18746 }
18747 #[repr(transparent)]
18748 pub struct RenderPassMultiviewCreateInfoBuilder<'a> {
18749     inner: RenderPassMultiviewCreateInfo,
18750     marker: ::std::marker::PhantomData<&'a ()>,
18751 }
18752 unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {}
18753 unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {}
18754 impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> {
18755     type Target = RenderPassMultiviewCreateInfo;
deref(&self) -> &Self::Target18756     fn deref(&self) -> &Self::Target {
18757         &self.inner
18758     }
18759 }
18760 impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18761     fn deref_mut(&mut self) -> &mut Self::Target {
18762         &mut self.inner
18763     }
18764 }
18765 impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
view_masks(mut self, view_masks: &'a [u32]) -> RenderPassMultiviewCreateInfoBuilder<'a>18766     pub fn view_masks(mut self, view_masks: &'a [u32]) -> RenderPassMultiviewCreateInfoBuilder<'a> {
18767         self.inner.subpass_count = view_masks.len() as _;
18768         self.inner.p_view_masks = view_masks.as_ptr();
18769         self
18770     }
view_offsets( mut self, view_offsets: &'a [i32], ) -> RenderPassMultiviewCreateInfoBuilder<'a>18771     pub fn view_offsets(
18772         mut self,
18773         view_offsets: &'a [i32],
18774     ) -> RenderPassMultiviewCreateInfoBuilder<'a> {
18775         self.inner.dependency_count = view_offsets.len() as _;
18776         self.inner.p_view_offsets = view_offsets.as_ptr();
18777         self
18778     }
correlation_masks( mut self, correlation_masks: &'a [u32], ) -> RenderPassMultiviewCreateInfoBuilder<'a>18779     pub fn correlation_masks(
18780         mut self,
18781         correlation_masks: &'a [u32],
18782     ) -> RenderPassMultiviewCreateInfoBuilder<'a> {
18783         self.inner.correlation_mask_count = correlation_masks.len() as _;
18784         self.inner.p_correlation_masks = correlation_masks.as_ptr();
18785         self
18786     }
18787     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18788     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18789     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassMultiviewCreateInfo18790     pub fn build(self) -> RenderPassMultiviewCreateInfo {
18791         self.inner
18792     }
18793 }
18794 #[repr(C)]
18795 #[derive(Copy, Clone, Debug)]
18796 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilities2EXT.html>"]
18797 pub struct SurfaceCapabilities2EXT {
18798     pub s_type: StructureType,
18799     pub p_next: *mut c_void,
18800     pub min_image_count: u32,
18801     pub max_image_count: u32,
18802     pub current_extent: Extent2D,
18803     pub min_image_extent: Extent2D,
18804     pub max_image_extent: Extent2D,
18805     pub max_image_array_layers: u32,
18806     pub supported_transforms: SurfaceTransformFlagsKHR,
18807     pub current_transform: SurfaceTransformFlagsKHR,
18808     pub supported_composite_alpha: CompositeAlphaFlagsKHR,
18809     pub supported_usage_flags: ImageUsageFlags,
18810     pub supported_surface_counters: SurfaceCounterFlagsEXT,
18811 }
18812 impl ::std::default::Default for SurfaceCapabilities2EXT {
default() -> SurfaceCapabilities2EXT18813     fn default() -> SurfaceCapabilities2EXT {
18814         SurfaceCapabilities2EXT {
18815             s_type: StructureType::SURFACE_CAPABILITIES_2_EXT,
18816             p_next: ::std::ptr::null_mut(),
18817             min_image_count: u32::default(),
18818             max_image_count: u32::default(),
18819             current_extent: Extent2D::default(),
18820             min_image_extent: Extent2D::default(),
18821             max_image_extent: Extent2D::default(),
18822             max_image_array_layers: u32::default(),
18823             supported_transforms: SurfaceTransformFlagsKHR::default(),
18824             current_transform: SurfaceTransformFlagsKHR::default(),
18825             supported_composite_alpha: CompositeAlphaFlagsKHR::default(),
18826             supported_usage_flags: ImageUsageFlags::default(),
18827             supported_surface_counters: SurfaceCounterFlagsEXT::default(),
18828         }
18829     }
18830 }
18831 impl SurfaceCapabilities2EXT {
builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a>18832     pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> {
18833         SurfaceCapabilities2EXTBuilder {
18834             inner: SurfaceCapabilities2EXT::default(),
18835             marker: ::std::marker::PhantomData,
18836         }
18837     }
18838 }
18839 #[repr(transparent)]
18840 pub struct SurfaceCapabilities2EXTBuilder<'a> {
18841     inner: SurfaceCapabilities2EXT,
18842     marker: ::std::marker::PhantomData<&'a ()>,
18843 }
18844 pub unsafe trait ExtendsSurfaceCapabilities2EXT {}
18845 impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> {
18846     type Target = SurfaceCapabilities2EXT;
deref(&self) -> &Self::Target18847     fn deref(&self) -> &Self::Target {
18848         &self.inner
18849     }
18850 }
18851 impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18852     fn deref_mut(&mut self) -> &mut Self::Target {
18853         &mut self.inner
18854     }
18855 }
18856 impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a>18857     pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a> {
18858         self.inner.min_image_count = min_image_count;
18859         self
18860     }
max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a>18861     pub fn max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a> {
18862         self.inner.max_image_count = max_image_count;
18863         self
18864     }
current_extent( mut self, current_extent: Extent2D, ) -> SurfaceCapabilities2EXTBuilder<'a>18865     pub fn current_extent(
18866         mut self,
18867         current_extent: Extent2D,
18868     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18869         self.inner.current_extent = current_extent;
18870         self
18871     }
min_image_extent( mut self, min_image_extent: Extent2D, ) -> SurfaceCapabilities2EXTBuilder<'a>18872     pub fn min_image_extent(
18873         mut self,
18874         min_image_extent: Extent2D,
18875     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18876         self.inner.min_image_extent = min_image_extent;
18877         self
18878     }
max_image_extent( mut self, max_image_extent: Extent2D, ) -> SurfaceCapabilities2EXTBuilder<'a>18879     pub fn max_image_extent(
18880         mut self,
18881         max_image_extent: Extent2D,
18882     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18883         self.inner.max_image_extent = max_image_extent;
18884         self
18885     }
max_image_array_layers( mut self, max_image_array_layers: u32, ) -> SurfaceCapabilities2EXTBuilder<'a>18886     pub fn max_image_array_layers(
18887         mut self,
18888         max_image_array_layers: u32,
18889     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18890         self.inner.max_image_array_layers = max_image_array_layers;
18891         self
18892     }
supported_transforms( mut self, supported_transforms: SurfaceTransformFlagsKHR, ) -> SurfaceCapabilities2EXTBuilder<'a>18893     pub fn supported_transforms(
18894         mut self,
18895         supported_transforms: SurfaceTransformFlagsKHR,
18896     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18897         self.inner.supported_transforms = supported_transforms;
18898         self
18899     }
current_transform( mut self, current_transform: SurfaceTransformFlagsKHR, ) -> SurfaceCapabilities2EXTBuilder<'a>18900     pub fn current_transform(
18901         mut self,
18902         current_transform: SurfaceTransformFlagsKHR,
18903     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18904         self.inner.current_transform = current_transform;
18905         self
18906     }
supported_composite_alpha( mut self, supported_composite_alpha: CompositeAlphaFlagsKHR, ) -> SurfaceCapabilities2EXTBuilder<'a>18907     pub fn supported_composite_alpha(
18908         mut self,
18909         supported_composite_alpha: CompositeAlphaFlagsKHR,
18910     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18911         self.inner.supported_composite_alpha = supported_composite_alpha;
18912         self
18913     }
supported_usage_flags( mut self, supported_usage_flags: ImageUsageFlags, ) -> SurfaceCapabilities2EXTBuilder<'a>18914     pub fn supported_usage_flags(
18915         mut self,
18916         supported_usage_flags: ImageUsageFlags,
18917     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18918         self.inner.supported_usage_flags = supported_usage_flags;
18919         self
18920     }
supported_surface_counters( mut self, supported_surface_counters: SurfaceCounterFlagsEXT, ) -> SurfaceCapabilities2EXTBuilder<'a>18921     pub fn supported_surface_counters(
18922         mut self,
18923         supported_surface_counters: SurfaceCounterFlagsEXT,
18924     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18925         self.inner.supported_surface_counters = supported_surface_counters;
18926         self
18927     }
18928     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
18929     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
18930     #[doc = r" valid extension structs can be pushed into the chain."]
18931     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
18932     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSurfaceCapabilities2EXT>( mut self, next: &'a mut T, ) -> SurfaceCapabilities2EXTBuilder<'a>18933     pub fn push_next<T: ExtendsSurfaceCapabilities2EXT>(
18934         mut self,
18935         next: &'a mut T,
18936     ) -> SurfaceCapabilities2EXTBuilder<'a> {
18937         unsafe {
18938             let next_ptr = next as *mut T as *mut BaseOutStructure;
18939             let last_next = ptr_chain_iter(next).last().unwrap();
18940             (*last_next).p_next = self.inner.p_next as _;
18941             self.inner.p_next = next_ptr as _;
18942         }
18943         self
18944     }
18945     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
18946     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
18947     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilities2EXT18948     pub fn build(self) -> SurfaceCapabilities2EXT {
18949         self.inner
18950     }
18951 }
18952 #[repr(C)]
18953 #[derive(Copy, Clone, Debug)]
18954 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPowerInfoEXT.html>"]
18955 pub struct DisplayPowerInfoEXT {
18956     pub s_type: StructureType,
18957     pub p_next: *const c_void,
18958     pub power_state: DisplayPowerStateEXT,
18959 }
18960 impl ::std::default::Default for DisplayPowerInfoEXT {
default() -> DisplayPowerInfoEXT18961     fn default() -> DisplayPowerInfoEXT {
18962         DisplayPowerInfoEXT {
18963             s_type: StructureType::DISPLAY_POWER_INFO_EXT,
18964             p_next: ::std::ptr::null(),
18965             power_state: DisplayPowerStateEXT::default(),
18966         }
18967     }
18968 }
18969 impl DisplayPowerInfoEXT {
builder<'a>() -> DisplayPowerInfoEXTBuilder<'a>18970     pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> {
18971         DisplayPowerInfoEXTBuilder {
18972             inner: DisplayPowerInfoEXT::default(),
18973             marker: ::std::marker::PhantomData,
18974         }
18975     }
18976 }
18977 #[repr(transparent)]
18978 pub struct DisplayPowerInfoEXTBuilder<'a> {
18979     inner: DisplayPowerInfoEXT,
18980     marker: ::std::marker::PhantomData<&'a ()>,
18981 }
18982 pub unsafe trait ExtendsDisplayPowerInfoEXT {}
18983 impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> {
18984     type Target = DisplayPowerInfoEXT;
deref(&self) -> &Self::Target18985     fn deref(&self) -> &Self::Target {
18986         &self.inner
18987     }
18988 }
18989 impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target18990     fn deref_mut(&mut self) -> &mut Self::Target {
18991         &mut self.inner
18992     }
18993 }
18994 impl<'a> DisplayPowerInfoEXTBuilder<'a> {
power_state( mut self, power_state: DisplayPowerStateEXT, ) -> DisplayPowerInfoEXTBuilder<'a>18995     pub fn power_state(
18996         mut self,
18997         power_state: DisplayPowerStateEXT,
18998     ) -> DisplayPowerInfoEXTBuilder<'a> {
18999         self.inner.power_state = power_state;
19000         self
19001     }
19002     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19003     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19004     #[doc = r" valid extension structs can be pushed into the chain."]
19005     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19006     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayPowerInfoEXT>( mut self, next: &'a mut T, ) -> DisplayPowerInfoEXTBuilder<'a>19007     pub fn push_next<T: ExtendsDisplayPowerInfoEXT>(
19008         mut self,
19009         next: &'a mut T,
19010     ) -> DisplayPowerInfoEXTBuilder<'a> {
19011         unsafe {
19012             let next_ptr = next as *mut T as *mut BaseOutStructure;
19013             let last_next = ptr_chain_iter(next).last().unwrap();
19014             (*last_next).p_next = self.inner.p_next as _;
19015             self.inner.p_next = next_ptr as _;
19016         }
19017         self
19018     }
19019     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19020     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19021     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPowerInfoEXT19022     pub fn build(self) -> DisplayPowerInfoEXT {
19023         self.inner
19024     }
19025 }
19026 #[repr(C)]
19027 #[derive(Copy, Clone, Debug)]
19028 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceEventInfoEXT.html>"]
19029 pub struct DeviceEventInfoEXT {
19030     pub s_type: StructureType,
19031     pub p_next: *const c_void,
19032     pub device_event: DeviceEventTypeEXT,
19033 }
19034 impl ::std::default::Default for DeviceEventInfoEXT {
default() -> DeviceEventInfoEXT19035     fn default() -> DeviceEventInfoEXT {
19036         DeviceEventInfoEXT {
19037             s_type: StructureType::DEVICE_EVENT_INFO_EXT,
19038             p_next: ::std::ptr::null(),
19039             device_event: DeviceEventTypeEXT::default(),
19040         }
19041     }
19042 }
19043 impl DeviceEventInfoEXT {
builder<'a>() -> DeviceEventInfoEXTBuilder<'a>19044     pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> {
19045         DeviceEventInfoEXTBuilder {
19046             inner: DeviceEventInfoEXT::default(),
19047             marker: ::std::marker::PhantomData,
19048         }
19049     }
19050 }
19051 #[repr(transparent)]
19052 pub struct DeviceEventInfoEXTBuilder<'a> {
19053     inner: DeviceEventInfoEXT,
19054     marker: ::std::marker::PhantomData<&'a ()>,
19055 }
19056 pub unsafe trait ExtendsDeviceEventInfoEXT {}
19057 impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> {
19058     type Target = DeviceEventInfoEXT;
deref(&self) -> &Self::Target19059     fn deref(&self) -> &Self::Target {
19060         &self.inner
19061     }
19062 }
19063 impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19064     fn deref_mut(&mut self) -> &mut Self::Target {
19065         &mut self.inner
19066     }
19067 }
19068 impl<'a> DeviceEventInfoEXTBuilder<'a> {
device_event( mut self, device_event: DeviceEventTypeEXT, ) -> DeviceEventInfoEXTBuilder<'a>19069     pub fn device_event(
19070         mut self,
19071         device_event: DeviceEventTypeEXT,
19072     ) -> DeviceEventInfoEXTBuilder<'a> {
19073         self.inner.device_event = device_event;
19074         self
19075     }
19076     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19077     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19078     #[doc = r" valid extension structs can be pushed into the chain."]
19079     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19080     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceEventInfoEXT>( mut self, next: &'a mut T, ) -> DeviceEventInfoEXTBuilder<'a>19081     pub fn push_next<T: ExtendsDeviceEventInfoEXT>(
19082         mut self,
19083         next: &'a mut T,
19084     ) -> DeviceEventInfoEXTBuilder<'a> {
19085         unsafe {
19086             let next_ptr = next as *mut T as *mut BaseOutStructure;
19087             let last_next = ptr_chain_iter(next).last().unwrap();
19088             (*last_next).p_next = self.inner.p_next as _;
19089             self.inner.p_next = next_ptr as _;
19090         }
19091         self
19092     }
19093     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19094     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19095     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceEventInfoEXT19096     pub fn build(self) -> DeviceEventInfoEXT {
19097         self.inner
19098     }
19099 }
19100 #[repr(C)]
19101 #[derive(Copy, Clone, Debug)]
19102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayEventInfoEXT.html>"]
19103 pub struct DisplayEventInfoEXT {
19104     pub s_type: StructureType,
19105     pub p_next: *const c_void,
19106     pub display_event: DisplayEventTypeEXT,
19107 }
19108 impl ::std::default::Default for DisplayEventInfoEXT {
default() -> DisplayEventInfoEXT19109     fn default() -> DisplayEventInfoEXT {
19110         DisplayEventInfoEXT {
19111             s_type: StructureType::DISPLAY_EVENT_INFO_EXT,
19112             p_next: ::std::ptr::null(),
19113             display_event: DisplayEventTypeEXT::default(),
19114         }
19115     }
19116 }
19117 impl DisplayEventInfoEXT {
builder<'a>() -> DisplayEventInfoEXTBuilder<'a>19118     pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> {
19119         DisplayEventInfoEXTBuilder {
19120             inner: DisplayEventInfoEXT::default(),
19121             marker: ::std::marker::PhantomData,
19122         }
19123     }
19124 }
19125 #[repr(transparent)]
19126 pub struct DisplayEventInfoEXTBuilder<'a> {
19127     inner: DisplayEventInfoEXT,
19128     marker: ::std::marker::PhantomData<&'a ()>,
19129 }
19130 pub unsafe trait ExtendsDisplayEventInfoEXT {}
19131 impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> {
19132     type Target = DisplayEventInfoEXT;
deref(&self) -> &Self::Target19133     fn deref(&self) -> &Self::Target {
19134         &self.inner
19135     }
19136 }
19137 impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19138     fn deref_mut(&mut self) -> &mut Self::Target {
19139         &mut self.inner
19140     }
19141 }
19142 impl<'a> DisplayEventInfoEXTBuilder<'a> {
display_event( mut self, display_event: DisplayEventTypeEXT, ) -> DisplayEventInfoEXTBuilder<'a>19143     pub fn display_event(
19144         mut self,
19145         display_event: DisplayEventTypeEXT,
19146     ) -> DisplayEventInfoEXTBuilder<'a> {
19147         self.inner.display_event = display_event;
19148         self
19149     }
19150     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19151     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19152     #[doc = r" valid extension structs can be pushed into the chain."]
19153     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19154     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayEventInfoEXT>( mut self, next: &'a mut T, ) -> DisplayEventInfoEXTBuilder<'a>19155     pub fn push_next<T: ExtendsDisplayEventInfoEXT>(
19156         mut self,
19157         next: &'a mut T,
19158     ) -> DisplayEventInfoEXTBuilder<'a> {
19159         unsafe {
19160             let next_ptr = next as *mut T as *mut BaseOutStructure;
19161             let last_next = ptr_chain_iter(next).last().unwrap();
19162             (*last_next).p_next = self.inner.p_next as _;
19163             self.inner.p_next = next_ptr as _;
19164         }
19165         self
19166     }
19167     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19168     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19169     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayEventInfoEXT19170     pub fn build(self) -> DisplayEventInfoEXT {
19171         self.inner
19172     }
19173 }
19174 #[repr(C)]
19175 #[derive(Copy, Clone, Debug)]
19176 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html>"]
19177 pub struct SwapchainCounterCreateInfoEXT {
19178     pub s_type: StructureType,
19179     pub p_next: *const c_void,
19180     pub surface_counters: SurfaceCounterFlagsEXT,
19181 }
19182 impl ::std::default::Default for SwapchainCounterCreateInfoEXT {
default() -> SwapchainCounterCreateInfoEXT19183     fn default() -> SwapchainCounterCreateInfoEXT {
19184         SwapchainCounterCreateInfoEXT {
19185             s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
19186             p_next: ::std::ptr::null(),
19187             surface_counters: SurfaceCounterFlagsEXT::default(),
19188         }
19189     }
19190 }
19191 impl SwapchainCounterCreateInfoEXT {
builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a>19192     pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> {
19193         SwapchainCounterCreateInfoEXTBuilder {
19194             inner: SwapchainCounterCreateInfoEXT::default(),
19195             marker: ::std::marker::PhantomData,
19196         }
19197     }
19198 }
19199 #[repr(transparent)]
19200 pub struct SwapchainCounterCreateInfoEXTBuilder<'a> {
19201     inner: SwapchainCounterCreateInfoEXT,
19202     marker: ::std::marker::PhantomData<&'a ()>,
19203 }
19204 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {}
19205 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {}
19206 impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> {
19207     type Target = SwapchainCounterCreateInfoEXT;
deref(&self) -> &Self::Target19208     fn deref(&self) -> &Self::Target {
19209         &self.inner
19210     }
19211 }
19212 impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19213     fn deref_mut(&mut self) -> &mut Self::Target {
19214         &mut self.inner
19215     }
19216 }
19217 impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
surface_counters( mut self, surface_counters: SurfaceCounterFlagsEXT, ) -> SwapchainCounterCreateInfoEXTBuilder<'a>19218     pub fn surface_counters(
19219         mut self,
19220         surface_counters: SurfaceCounterFlagsEXT,
19221     ) -> SwapchainCounterCreateInfoEXTBuilder<'a> {
19222         self.inner.surface_counters = surface_counters;
19223         self
19224     }
19225     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19226     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19227     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainCounterCreateInfoEXT19228     pub fn build(self) -> SwapchainCounterCreateInfoEXT {
19229         self.inner
19230     }
19231 }
19232 #[repr(C)]
19233 #[derive(Copy, Clone, Debug)]
19234 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceGroupProperties.html>"]
19235 pub struct PhysicalDeviceGroupProperties {
19236     pub s_type: StructureType,
19237     pub p_next: *mut c_void,
19238     pub physical_device_count: u32,
19239     pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
19240     pub subset_allocation: Bool32,
19241 }
19242 impl ::std::default::Default for PhysicalDeviceGroupProperties {
default() -> PhysicalDeviceGroupProperties19243     fn default() -> PhysicalDeviceGroupProperties {
19244         PhysicalDeviceGroupProperties {
19245             s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES,
19246             p_next: ::std::ptr::null_mut(),
19247             physical_device_count: u32::default(),
19248             physical_devices: unsafe { ::std::mem::zeroed() },
19249             subset_allocation: Bool32::default(),
19250         }
19251     }
19252 }
19253 impl PhysicalDeviceGroupProperties {
builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a>19254     pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> {
19255         PhysicalDeviceGroupPropertiesBuilder {
19256             inner: PhysicalDeviceGroupProperties::default(),
19257             marker: ::std::marker::PhantomData,
19258         }
19259     }
19260 }
19261 #[repr(transparent)]
19262 pub struct PhysicalDeviceGroupPropertiesBuilder<'a> {
19263     inner: PhysicalDeviceGroupProperties,
19264     marker: ::std::marker::PhantomData<&'a ()>,
19265 }
19266 pub unsafe trait ExtendsPhysicalDeviceGroupProperties {}
19267 impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> {
19268     type Target = PhysicalDeviceGroupProperties;
deref(&self) -> &Self::Target19269     fn deref(&self) -> &Self::Target {
19270         &self.inner
19271     }
19272 }
19273 impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19274     fn deref_mut(&mut self) -> &mut Self::Target {
19275         &mut self.inner
19276     }
19277 }
19278 impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
physical_device_count( mut self, physical_device_count: u32, ) -> PhysicalDeviceGroupPropertiesBuilder<'a>19279     pub fn physical_device_count(
19280         mut self,
19281         physical_device_count: u32,
19282     ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
19283         self.inner.physical_device_count = physical_device_count;
19284         self
19285     }
physical_devices( mut self, physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], ) -> PhysicalDeviceGroupPropertiesBuilder<'a>19286     pub fn physical_devices(
19287         mut self,
19288         physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
19289     ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
19290         self.inner.physical_devices = physical_devices;
19291         self
19292     }
subset_allocation( mut self, subset_allocation: bool, ) -> PhysicalDeviceGroupPropertiesBuilder<'a>19293     pub fn subset_allocation(
19294         mut self,
19295         subset_allocation: bool,
19296     ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
19297         self.inner.subset_allocation = subset_allocation.into();
19298         self
19299     }
19300     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19301     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19302     #[doc = r" valid extension structs can be pushed into the chain."]
19303     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19304     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceGroupProperties>( mut self, next: &'a mut T, ) -> PhysicalDeviceGroupPropertiesBuilder<'a>19305     pub fn push_next<T: ExtendsPhysicalDeviceGroupProperties>(
19306         mut self,
19307         next: &'a mut T,
19308     ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
19309         unsafe {
19310             let next_ptr = next as *mut T as *mut BaseOutStructure;
19311             let last_next = ptr_chain_iter(next).last().unwrap();
19312             (*last_next).p_next = self.inner.p_next as _;
19313             self.inner.p_next = next_ptr as _;
19314         }
19315         self
19316     }
19317     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19318     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19319     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceGroupProperties19320     pub fn build(self) -> PhysicalDeviceGroupProperties {
19321         self.inner
19322     }
19323 }
19324 #[repr(C)]
19325 #[derive(Copy, Clone, Debug)]
19326 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagsInfo.html>"]
19327 pub struct MemoryAllocateFlagsInfo {
19328     pub s_type: StructureType,
19329     pub p_next: *const c_void,
19330     pub flags: MemoryAllocateFlags,
19331     pub device_mask: u32,
19332 }
19333 impl ::std::default::Default for MemoryAllocateFlagsInfo {
default() -> MemoryAllocateFlagsInfo19334     fn default() -> MemoryAllocateFlagsInfo {
19335         MemoryAllocateFlagsInfo {
19336             s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO,
19337             p_next: ::std::ptr::null(),
19338             flags: MemoryAllocateFlags::default(),
19339             device_mask: u32::default(),
19340         }
19341     }
19342 }
19343 impl MemoryAllocateFlagsInfo {
builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a>19344     pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> {
19345         MemoryAllocateFlagsInfoBuilder {
19346             inner: MemoryAllocateFlagsInfo::default(),
19347             marker: ::std::marker::PhantomData,
19348         }
19349     }
19350 }
19351 #[repr(transparent)]
19352 pub struct MemoryAllocateFlagsInfoBuilder<'a> {
19353     inner: MemoryAllocateFlagsInfo,
19354     marker: ::std::marker::PhantomData<&'a ()>,
19355 }
19356 unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {}
19357 unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {}
19358 impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> {
19359     type Target = MemoryAllocateFlagsInfo;
deref(&self) -> &Self::Target19360     fn deref(&self) -> &Self::Target {
19361         &self.inner
19362     }
19363 }
19364 impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19365     fn deref_mut(&mut self) -> &mut Self::Target {
19366         &mut self.inner
19367     }
19368 }
19369 impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
flags(mut self, flags: MemoryAllocateFlags) -> MemoryAllocateFlagsInfoBuilder<'a>19370     pub fn flags(mut self, flags: MemoryAllocateFlags) -> MemoryAllocateFlagsInfoBuilder<'a> {
19371         self.inner.flags = flags;
19372         self
19373     }
device_mask(mut self, device_mask: u32) -> MemoryAllocateFlagsInfoBuilder<'a>19374     pub fn device_mask(mut self, device_mask: u32) -> MemoryAllocateFlagsInfoBuilder<'a> {
19375         self.inner.device_mask = device_mask;
19376         self
19377     }
19378     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19379     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19380     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryAllocateFlagsInfo19381     pub fn build(self) -> MemoryAllocateFlagsInfo {
19382         self.inner
19383     }
19384 }
19385 #[repr(C)]
19386 #[derive(Copy, Clone, Debug)]
19387 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindBufferMemoryInfo.html>"]
19388 pub struct BindBufferMemoryInfo {
19389     pub s_type: StructureType,
19390     pub p_next: *const c_void,
19391     pub buffer: Buffer,
19392     pub memory: DeviceMemory,
19393     pub memory_offset: DeviceSize,
19394 }
19395 impl ::std::default::Default for BindBufferMemoryInfo {
default() -> BindBufferMemoryInfo19396     fn default() -> BindBufferMemoryInfo {
19397         BindBufferMemoryInfo {
19398             s_type: StructureType::BIND_BUFFER_MEMORY_INFO,
19399             p_next: ::std::ptr::null(),
19400             buffer: Buffer::default(),
19401             memory: DeviceMemory::default(),
19402             memory_offset: DeviceSize::default(),
19403         }
19404     }
19405 }
19406 impl BindBufferMemoryInfo {
builder<'a>() -> BindBufferMemoryInfoBuilder<'a>19407     pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> {
19408         BindBufferMemoryInfoBuilder {
19409             inner: BindBufferMemoryInfo::default(),
19410             marker: ::std::marker::PhantomData,
19411         }
19412     }
19413 }
19414 #[repr(transparent)]
19415 pub struct BindBufferMemoryInfoBuilder<'a> {
19416     inner: BindBufferMemoryInfo,
19417     marker: ::std::marker::PhantomData<&'a ()>,
19418 }
19419 pub unsafe trait ExtendsBindBufferMemoryInfo {}
19420 impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> {
19421     type Target = BindBufferMemoryInfo;
deref(&self) -> &Self::Target19422     fn deref(&self) -> &Self::Target {
19423         &self.inner
19424     }
19425 }
19426 impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19427     fn deref_mut(&mut self) -> &mut Self::Target {
19428         &mut self.inner
19429     }
19430 }
19431 impl<'a> BindBufferMemoryInfoBuilder<'a> {
buffer(mut self, buffer: Buffer) -> BindBufferMemoryInfoBuilder<'a>19432     pub fn buffer(mut self, buffer: Buffer) -> BindBufferMemoryInfoBuilder<'a> {
19433         self.inner.buffer = buffer;
19434         self
19435     }
memory(mut self, memory: DeviceMemory) -> BindBufferMemoryInfoBuilder<'a>19436     pub fn memory(mut self, memory: DeviceMemory) -> BindBufferMemoryInfoBuilder<'a> {
19437         self.inner.memory = memory;
19438         self
19439     }
memory_offset(mut self, memory_offset: DeviceSize) -> BindBufferMemoryInfoBuilder<'a>19440     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> BindBufferMemoryInfoBuilder<'a> {
19441         self.inner.memory_offset = memory_offset;
19442         self
19443     }
19444     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19445     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19446     #[doc = r" valid extension structs can be pushed into the chain."]
19447     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19448     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBindBufferMemoryInfo>( mut self, next: &'a mut T, ) -> BindBufferMemoryInfoBuilder<'a>19449     pub fn push_next<T: ExtendsBindBufferMemoryInfo>(
19450         mut self,
19451         next: &'a mut T,
19452     ) -> BindBufferMemoryInfoBuilder<'a> {
19453         unsafe {
19454             let next_ptr = next as *mut T as *mut BaseOutStructure;
19455             let last_next = ptr_chain_iter(next).last().unwrap();
19456             (*last_next).p_next = self.inner.p_next as _;
19457             self.inner.p_next = next_ptr as _;
19458         }
19459         self
19460     }
19461     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19462     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19463     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindBufferMemoryInfo19464     pub fn build(self) -> BindBufferMemoryInfo {
19465         self.inner
19466     }
19467 }
19468 #[repr(C)]
19469 #[derive(Copy, Clone, Debug)]
19470 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html>"]
19471 pub struct BindBufferMemoryDeviceGroupInfo {
19472     pub s_type: StructureType,
19473     pub p_next: *const c_void,
19474     pub device_index_count: u32,
19475     pub p_device_indices: *const u32,
19476 }
19477 impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo {
default() -> BindBufferMemoryDeviceGroupInfo19478     fn default() -> BindBufferMemoryDeviceGroupInfo {
19479         BindBufferMemoryDeviceGroupInfo {
19480             s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
19481             p_next: ::std::ptr::null(),
19482             device_index_count: u32::default(),
19483             p_device_indices: ::std::ptr::null(),
19484         }
19485     }
19486 }
19487 impl BindBufferMemoryDeviceGroupInfo {
builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a>19488     pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19489         BindBufferMemoryDeviceGroupInfoBuilder {
19490             inner: BindBufferMemoryDeviceGroupInfo::default(),
19491             marker: ::std::marker::PhantomData,
19492         }
19493     }
19494 }
19495 #[repr(transparent)]
19496 pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19497     inner: BindBufferMemoryDeviceGroupInfo,
19498     marker: ::std::marker::PhantomData<&'a ()>,
19499 }
19500 unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {}
19501 unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {}
19502 impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19503     type Target = BindBufferMemoryDeviceGroupInfo;
deref(&self) -> &Self::Target19504     fn deref(&self) -> &Self::Target {
19505         &self.inner
19506     }
19507 }
19508 impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19509     fn deref_mut(&mut self) -> &mut Self::Target {
19510         &mut self.inner
19511     }
19512 }
19513 impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
device_indices( mut self, device_indices: &'a [u32], ) -> BindBufferMemoryDeviceGroupInfoBuilder<'a>19514     pub fn device_indices(
19515         mut self,
19516         device_indices: &'a [u32],
19517     ) -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
19518         self.inner.device_index_count = device_indices.len() as _;
19519         self.inner.p_device_indices = device_indices.as_ptr();
19520         self
19521     }
19522     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19523     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19524     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindBufferMemoryDeviceGroupInfo19525     pub fn build(self) -> BindBufferMemoryDeviceGroupInfo {
19526         self.inner
19527     }
19528 }
19529 #[repr(C)]
19530 #[derive(Copy, Clone, Debug)]
19531 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemoryInfo.html>"]
19532 pub struct BindImageMemoryInfo {
19533     pub s_type: StructureType,
19534     pub p_next: *const c_void,
19535     pub image: Image,
19536     pub memory: DeviceMemory,
19537     pub memory_offset: DeviceSize,
19538 }
19539 impl ::std::default::Default for BindImageMemoryInfo {
default() -> BindImageMemoryInfo19540     fn default() -> BindImageMemoryInfo {
19541         BindImageMemoryInfo {
19542             s_type: StructureType::BIND_IMAGE_MEMORY_INFO,
19543             p_next: ::std::ptr::null(),
19544             image: Image::default(),
19545             memory: DeviceMemory::default(),
19546             memory_offset: DeviceSize::default(),
19547         }
19548     }
19549 }
19550 impl BindImageMemoryInfo {
builder<'a>() -> BindImageMemoryInfoBuilder<'a>19551     pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> {
19552         BindImageMemoryInfoBuilder {
19553             inner: BindImageMemoryInfo::default(),
19554             marker: ::std::marker::PhantomData,
19555         }
19556     }
19557 }
19558 #[repr(transparent)]
19559 pub struct BindImageMemoryInfoBuilder<'a> {
19560     inner: BindImageMemoryInfo,
19561     marker: ::std::marker::PhantomData<&'a ()>,
19562 }
19563 pub unsafe trait ExtendsBindImageMemoryInfo {}
19564 impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> {
19565     type Target = BindImageMemoryInfo;
deref(&self) -> &Self::Target19566     fn deref(&self) -> &Self::Target {
19567         &self.inner
19568     }
19569 }
19570 impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19571     fn deref_mut(&mut self) -> &mut Self::Target {
19572         &mut self.inner
19573     }
19574 }
19575 impl<'a> BindImageMemoryInfoBuilder<'a> {
image(mut self, image: Image) -> BindImageMemoryInfoBuilder<'a>19576     pub fn image(mut self, image: Image) -> BindImageMemoryInfoBuilder<'a> {
19577         self.inner.image = image;
19578         self
19579     }
memory(mut self, memory: DeviceMemory) -> BindImageMemoryInfoBuilder<'a>19580     pub fn memory(mut self, memory: DeviceMemory) -> BindImageMemoryInfoBuilder<'a> {
19581         self.inner.memory = memory;
19582         self
19583     }
memory_offset(mut self, memory_offset: DeviceSize) -> BindImageMemoryInfoBuilder<'a>19584     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> BindImageMemoryInfoBuilder<'a> {
19585         self.inner.memory_offset = memory_offset;
19586         self
19587     }
19588     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
19589     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
19590     #[doc = r" valid extension structs can be pushed into the chain."]
19591     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
19592     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBindImageMemoryInfo>( mut self, next: &'a mut T, ) -> BindImageMemoryInfoBuilder<'a>19593     pub fn push_next<T: ExtendsBindImageMemoryInfo>(
19594         mut self,
19595         next: &'a mut T,
19596     ) -> BindImageMemoryInfoBuilder<'a> {
19597         unsafe {
19598             let next_ptr = next as *mut T as *mut BaseOutStructure;
19599             let last_next = ptr_chain_iter(next).last().unwrap();
19600             (*last_next).p_next = self.inner.p_next as _;
19601             self.inner.p_next = next_ptr as _;
19602         }
19603         self
19604     }
19605     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19606     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19607     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImageMemoryInfo19608     pub fn build(self) -> BindImageMemoryInfo {
19609         self.inner
19610     }
19611 }
19612 #[repr(C)]
19613 #[derive(Copy, Clone, Debug)]
19614 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html>"]
19615 pub struct BindImageMemoryDeviceGroupInfo {
19616     pub s_type: StructureType,
19617     pub p_next: *const c_void,
19618     pub device_index_count: u32,
19619     pub p_device_indices: *const u32,
19620     pub split_instance_bind_region_count: u32,
19621     pub p_split_instance_bind_regions: *const Rect2D,
19622 }
19623 impl ::std::default::Default for BindImageMemoryDeviceGroupInfo {
default() -> BindImageMemoryDeviceGroupInfo19624     fn default() -> BindImageMemoryDeviceGroupInfo {
19625         BindImageMemoryDeviceGroupInfo {
19626             s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
19627             p_next: ::std::ptr::null(),
19628             device_index_count: u32::default(),
19629             p_device_indices: ::std::ptr::null(),
19630             split_instance_bind_region_count: u32::default(),
19631             p_split_instance_bind_regions: ::std::ptr::null(),
19632         }
19633     }
19634 }
19635 impl BindImageMemoryDeviceGroupInfo {
builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a>19636     pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
19637         BindImageMemoryDeviceGroupInfoBuilder {
19638             inner: BindImageMemoryDeviceGroupInfo::default(),
19639             marker: ::std::marker::PhantomData,
19640         }
19641     }
19642 }
19643 #[repr(transparent)]
19644 pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> {
19645     inner: BindImageMemoryDeviceGroupInfo,
19646     marker: ::std::marker::PhantomData<&'a ()>,
19647 }
19648 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {}
19649 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {}
19650 impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> {
19651     type Target = BindImageMemoryDeviceGroupInfo;
deref(&self) -> &Self::Target19652     fn deref(&self) -> &Self::Target {
19653         &self.inner
19654     }
19655 }
19656 impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19657     fn deref_mut(&mut self) -> &mut Self::Target {
19658         &mut self.inner
19659     }
19660 }
19661 impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
device_indices( mut self, device_indices: &'a [u32], ) -> BindImageMemoryDeviceGroupInfoBuilder<'a>19662     pub fn device_indices(
19663         mut self,
19664         device_indices: &'a [u32],
19665     ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
19666         self.inner.device_index_count = device_indices.len() as _;
19667         self.inner.p_device_indices = device_indices.as_ptr();
19668         self
19669     }
split_instance_bind_regions( mut self, split_instance_bind_regions: &'a [Rect2D], ) -> BindImageMemoryDeviceGroupInfoBuilder<'a>19670     pub fn split_instance_bind_regions(
19671         mut self,
19672         split_instance_bind_regions: &'a [Rect2D],
19673     ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
19674         self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _;
19675         self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr();
19676         self
19677     }
19678     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19679     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19680     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImageMemoryDeviceGroupInfo19681     pub fn build(self) -> BindImageMemoryDeviceGroupInfo {
19682         self.inner
19683     }
19684 }
19685 #[repr(C)]
19686 #[derive(Copy, Clone, Debug)]
19687 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html>"]
19688 pub struct DeviceGroupRenderPassBeginInfo {
19689     pub s_type: StructureType,
19690     pub p_next: *const c_void,
19691     pub device_mask: u32,
19692     pub device_render_area_count: u32,
19693     pub p_device_render_areas: *const Rect2D,
19694 }
19695 impl ::std::default::Default for DeviceGroupRenderPassBeginInfo {
default() -> DeviceGroupRenderPassBeginInfo19696     fn default() -> DeviceGroupRenderPassBeginInfo {
19697         DeviceGroupRenderPassBeginInfo {
19698             s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
19699             p_next: ::std::ptr::null(),
19700             device_mask: u32::default(),
19701             device_render_area_count: u32::default(),
19702             p_device_render_areas: ::std::ptr::null(),
19703         }
19704     }
19705 }
19706 impl DeviceGroupRenderPassBeginInfo {
builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a>19707     pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
19708         DeviceGroupRenderPassBeginInfoBuilder {
19709             inner: DeviceGroupRenderPassBeginInfo::default(),
19710             marker: ::std::marker::PhantomData,
19711         }
19712     }
19713 }
19714 #[repr(transparent)]
19715 pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
19716     inner: DeviceGroupRenderPassBeginInfo,
19717     marker: ::std::marker::PhantomData<&'a ()>,
19718 }
19719 unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
19720 unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {}
19721 impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
19722     type Target = DeviceGroupRenderPassBeginInfo;
deref(&self) -> &Self::Target19723     fn deref(&self) -> &Self::Target {
19724         &self.inner
19725     }
19726 }
19727 impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19728     fn deref_mut(&mut self) -> &mut Self::Target {
19729         &mut self.inner
19730     }
19731 }
19732 impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
device_mask(mut self, device_mask: u32) -> DeviceGroupRenderPassBeginInfoBuilder<'a>19733     pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
19734         self.inner.device_mask = device_mask;
19735         self
19736     }
device_render_areas( mut self, device_render_areas: &'a [Rect2D], ) -> DeviceGroupRenderPassBeginInfoBuilder<'a>19737     pub fn device_render_areas(
19738         mut self,
19739         device_render_areas: &'a [Rect2D],
19740     ) -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
19741         self.inner.device_render_area_count = device_render_areas.len() as _;
19742         self.inner.p_device_render_areas = device_render_areas.as_ptr();
19743         self
19744     }
19745     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19746     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19747     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupRenderPassBeginInfo19748     pub fn build(self) -> DeviceGroupRenderPassBeginInfo {
19749         self.inner
19750     }
19751 }
19752 #[repr(C)]
19753 #[derive(Copy, Clone, Debug)]
19754 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html>"]
19755 pub struct DeviceGroupCommandBufferBeginInfo {
19756     pub s_type: StructureType,
19757     pub p_next: *const c_void,
19758     pub device_mask: u32,
19759 }
19760 impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo {
default() -> DeviceGroupCommandBufferBeginInfo19761     fn default() -> DeviceGroupCommandBufferBeginInfo {
19762         DeviceGroupCommandBufferBeginInfo {
19763             s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
19764             p_next: ::std::ptr::null(),
19765             device_mask: u32::default(),
19766         }
19767     }
19768 }
19769 impl DeviceGroupCommandBufferBeginInfo {
builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a>19770     pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
19771         DeviceGroupCommandBufferBeginInfoBuilder {
19772             inner: DeviceGroupCommandBufferBeginInfo::default(),
19773             marker: ::std::marker::PhantomData,
19774         }
19775     }
19776 }
19777 #[repr(transparent)]
19778 pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> {
19779     inner: DeviceGroupCommandBufferBeginInfo,
19780     marker: ::std::marker::PhantomData<&'a ()>,
19781 }
19782 unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {}
19783 unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {}
19784 impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
19785     type Target = DeviceGroupCommandBufferBeginInfo;
deref(&self) -> &Self::Target19786     fn deref(&self) -> &Self::Target {
19787         &self.inner
19788     }
19789 }
19790 impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19791     fn deref_mut(&mut self) -> &mut Self::Target {
19792         &mut self.inner
19793     }
19794 }
19795 impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
device_mask(mut self, device_mask: u32) -> DeviceGroupCommandBufferBeginInfoBuilder<'a>19796     pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
19797         self.inner.device_mask = device_mask;
19798         self
19799     }
19800     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19801     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19802     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupCommandBufferBeginInfo19803     pub fn build(self) -> DeviceGroupCommandBufferBeginInfo {
19804         self.inner
19805     }
19806 }
19807 #[repr(C)]
19808 #[derive(Copy, Clone, Debug)]
19809 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupSubmitInfo.html>"]
19810 pub struct DeviceGroupSubmitInfo {
19811     pub s_type: StructureType,
19812     pub p_next: *const c_void,
19813     pub wait_semaphore_count: u32,
19814     pub p_wait_semaphore_device_indices: *const u32,
19815     pub command_buffer_count: u32,
19816     pub p_command_buffer_device_masks: *const u32,
19817     pub signal_semaphore_count: u32,
19818     pub p_signal_semaphore_device_indices: *const u32,
19819 }
19820 impl ::std::default::Default for DeviceGroupSubmitInfo {
default() -> DeviceGroupSubmitInfo19821     fn default() -> DeviceGroupSubmitInfo {
19822         DeviceGroupSubmitInfo {
19823             s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO,
19824             p_next: ::std::ptr::null(),
19825             wait_semaphore_count: u32::default(),
19826             p_wait_semaphore_device_indices: ::std::ptr::null(),
19827             command_buffer_count: u32::default(),
19828             p_command_buffer_device_masks: ::std::ptr::null(),
19829             signal_semaphore_count: u32::default(),
19830             p_signal_semaphore_device_indices: ::std::ptr::null(),
19831         }
19832     }
19833 }
19834 impl DeviceGroupSubmitInfo {
builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a>19835     pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> {
19836         DeviceGroupSubmitInfoBuilder {
19837             inner: DeviceGroupSubmitInfo::default(),
19838             marker: ::std::marker::PhantomData,
19839         }
19840     }
19841 }
19842 #[repr(transparent)]
19843 pub struct DeviceGroupSubmitInfoBuilder<'a> {
19844     inner: DeviceGroupSubmitInfo,
19845     marker: ::std::marker::PhantomData<&'a ()>,
19846 }
19847 unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {}
19848 unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {}
19849 impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> {
19850     type Target = DeviceGroupSubmitInfo;
deref(&self) -> &Self::Target19851     fn deref(&self) -> &Self::Target {
19852         &self.inner
19853     }
19854 }
19855 impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19856     fn deref_mut(&mut self) -> &mut Self::Target {
19857         &mut self.inner
19858     }
19859 }
19860 impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
wait_semaphore_device_indices( mut self, wait_semaphore_device_indices: &'a [u32], ) -> DeviceGroupSubmitInfoBuilder<'a>19861     pub fn wait_semaphore_device_indices(
19862         mut self,
19863         wait_semaphore_device_indices: &'a [u32],
19864     ) -> DeviceGroupSubmitInfoBuilder<'a> {
19865         self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _;
19866         self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr();
19867         self
19868     }
command_buffer_device_masks( mut self, command_buffer_device_masks: &'a [u32], ) -> DeviceGroupSubmitInfoBuilder<'a>19869     pub fn command_buffer_device_masks(
19870         mut self,
19871         command_buffer_device_masks: &'a [u32],
19872     ) -> DeviceGroupSubmitInfoBuilder<'a> {
19873         self.inner.command_buffer_count = command_buffer_device_masks.len() as _;
19874         self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr();
19875         self
19876     }
signal_semaphore_device_indices( mut self, signal_semaphore_device_indices: &'a [u32], ) -> DeviceGroupSubmitInfoBuilder<'a>19877     pub fn signal_semaphore_device_indices(
19878         mut self,
19879         signal_semaphore_device_indices: &'a [u32],
19880     ) -> DeviceGroupSubmitInfoBuilder<'a> {
19881         self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _;
19882         self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr();
19883         self
19884     }
19885     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19886     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19887     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupSubmitInfo19888     pub fn build(self) -> DeviceGroupSubmitInfo {
19889         self.inner
19890     }
19891 }
19892 #[repr(C)]
19893 #[derive(Copy, Clone, Debug)]
19894 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupBindSparseInfo.html>"]
19895 pub struct DeviceGroupBindSparseInfo {
19896     pub s_type: StructureType,
19897     pub p_next: *const c_void,
19898     pub resource_device_index: u32,
19899     pub memory_device_index: u32,
19900 }
19901 impl ::std::default::Default for DeviceGroupBindSparseInfo {
default() -> DeviceGroupBindSparseInfo19902     fn default() -> DeviceGroupBindSparseInfo {
19903         DeviceGroupBindSparseInfo {
19904             s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO,
19905             p_next: ::std::ptr::null(),
19906             resource_device_index: u32::default(),
19907             memory_device_index: u32::default(),
19908         }
19909     }
19910 }
19911 impl DeviceGroupBindSparseInfo {
builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a>19912     pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> {
19913         DeviceGroupBindSparseInfoBuilder {
19914             inner: DeviceGroupBindSparseInfo::default(),
19915             marker: ::std::marker::PhantomData,
19916         }
19917     }
19918 }
19919 #[repr(transparent)]
19920 pub struct DeviceGroupBindSparseInfoBuilder<'a> {
19921     inner: DeviceGroupBindSparseInfo,
19922     marker: ::std::marker::PhantomData<&'a ()>,
19923 }
19924 unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {}
19925 unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {}
19926 impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> {
19927     type Target = DeviceGroupBindSparseInfo;
deref(&self) -> &Self::Target19928     fn deref(&self) -> &Self::Target {
19929         &self.inner
19930     }
19931 }
19932 impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19933     fn deref_mut(&mut self) -> &mut Self::Target {
19934         &mut self.inner
19935     }
19936 }
19937 impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
resource_device_index( mut self, resource_device_index: u32, ) -> DeviceGroupBindSparseInfoBuilder<'a>19938     pub fn resource_device_index(
19939         mut self,
19940         resource_device_index: u32,
19941     ) -> DeviceGroupBindSparseInfoBuilder<'a> {
19942         self.inner.resource_device_index = resource_device_index;
19943         self
19944     }
memory_device_index( mut self, memory_device_index: u32, ) -> DeviceGroupBindSparseInfoBuilder<'a>19945     pub fn memory_device_index(
19946         mut self,
19947         memory_device_index: u32,
19948     ) -> DeviceGroupBindSparseInfoBuilder<'a> {
19949         self.inner.memory_device_index = memory_device_index;
19950         self
19951     }
19952     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
19953     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
19954     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupBindSparseInfo19955     pub fn build(self) -> DeviceGroupBindSparseInfo {
19956         self.inner
19957     }
19958 }
19959 #[repr(C)]
19960 #[derive(Copy, Clone, Debug)]
19961 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>"]
19962 pub struct DeviceGroupPresentCapabilitiesKHR {
19963     pub s_type: StructureType,
19964     pub p_next: *const c_void,
19965     pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
19966     pub modes: DeviceGroupPresentModeFlagsKHR,
19967 }
19968 impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR {
default() -> DeviceGroupPresentCapabilitiesKHR19969     fn default() -> DeviceGroupPresentCapabilitiesKHR {
19970         DeviceGroupPresentCapabilitiesKHR {
19971             s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
19972             p_next: ::std::ptr::null(),
19973             present_mask: unsafe { ::std::mem::zeroed() },
19974             modes: DeviceGroupPresentModeFlagsKHR::default(),
19975         }
19976     }
19977 }
19978 impl DeviceGroupPresentCapabilitiesKHR {
builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a>19979     pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
19980         DeviceGroupPresentCapabilitiesKHRBuilder {
19981             inner: DeviceGroupPresentCapabilitiesKHR::default(),
19982             marker: ::std::marker::PhantomData,
19983         }
19984     }
19985 }
19986 #[repr(transparent)]
19987 pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
19988     inner: DeviceGroupPresentCapabilitiesKHR,
19989     marker: ::std::marker::PhantomData<&'a ()>,
19990 }
19991 pub unsafe trait ExtendsDeviceGroupPresentCapabilitiesKHR {}
19992 impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
19993     type Target = DeviceGroupPresentCapabilitiesKHR;
deref(&self) -> &Self::Target19994     fn deref(&self) -> &Self::Target {
19995         &self.inner
19996     }
19997 }
19998 impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target19999     fn deref_mut(&mut self) -> &mut Self::Target {
20000         &mut self.inner
20001     }
20002 }
20003 impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
present_mask( mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE], ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a>20004     pub fn present_mask(
20005         mut self,
20006         present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
20007     ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
20008         self.inner.present_mask = present_mask;
20009         self
20010     }
modes( mut self, modes: DeviceGroupPresentModeFlagsKHR, ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a>20011     pub fn modes(
20012         mut self,
20013         modes: DeviceGroupPresentModeFlagsKHR,
20014     ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
20015         self.inner.modes = modes;
20016         self
20017     }
20018     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20019     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20020     #[doc = r" valid extension structs can be pushed into the chain."]
20021     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20022     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceGroupPresentCapabilitiesKHR>( mut self, next: &'a mut T, ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a>20023     pub fn push_next<T: ExtendsDeviceGroupPresentCapabilitiesKHR>(
20024         mut self,
20025         next: &'a mut T,
20026     ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
20027         unsafe {
20028             let next_ptr = next as *mut T as *mut BaseOutStructure;
20029             let last_next = ptr_chain_iter(next).last().unwrap();
20030             (*last_next).p_next = self.inner.p_next as _;
20031             self.inner.p_next = next_ptr as _;
20032         }
20033         self
20034     }
20035     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20036     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20037     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupPresentCapabilitiesKHR20038     pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR {
20039         self.inner
20040     }
20041 }
20042 #[repr(C)]
20043 #[derive(Copy, Clone, Debug)]
20044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSwapchainCreateInfoKHR.html>"]
20045 pub struct ImageSwapchainCreateInfoKHR {
20046     pub s_type: StructureType,
20047     pub p_next: *const c_void,
20048     pub swapchain: SwapchainKHR,
20049 }
20050 impl ::std::default::Default for ImageSwapchainCreateInfoKHR {
default() -> ImageSwapchainCreateInfoKHR20051     fn default() -> ImageSwapchainCreateInfoKHR {
20052         ImageSwapchainCreateInfoKHR {
20053             s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
20054             p_next: ::std::ptr::null(),
20055             swapchain: SwapchainKHR::default(),
20056         }
20057     }
20058 }
20059 impl ImageSwapchainCreateInfoKHR {
builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a>20060     pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> {
20061         ImageSwapchainCreateInfoKHRBuilder {
20062             inner: ImageSwapchainCreateInfoKHR::default(),
20063             marker: ::std::marker::PhantomData,
20064         }
20065     }
20066 }
20067 #[repr(transparent)]
20068 pub struct ImageSwapchainCreateInfoKHRBuilder<'a> {
20069     inner: ImageSwapchainCreateInfoKHR,
20070     marker: ::std::marker::PhantomData<&'a ()>,
20071 }
20072 unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {}
20073 unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {}
20074 impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> {
20075     type Target = ImageSwapchainCreateInfoKHR;
deref(&self) -> &Self::Target20076     fn deref(&self) -> &Self::Target {
20077         &self.inner
20078     }
20079 }
20080 impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20081     fn deref_mut(&mut self) -> &mut Self::Target {
20082         &mut self.inner
20083     }
20084 }
20085 impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
swapchain(mut self, swapchain: SwapchainKHR) -> ImageSwapchainCreateInfoKHRBuilder<'a>20086     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> ImageSwapchainCreateInfoKHRBuilder<'a> {
20087         self.inner.swapchain = swapchain;
20088         self
20089     }
20090     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20091     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20092     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageSwapchainCreateInfoKHR20093     pub fn build(self) -> ImageSwapchainCreateInfoKHR {
20094         self.inner
20095     }
20096 }
20097 #[repr(C)]
20098 #[derive(Copy, Clone, Debug)]
20099 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html>"]
20100 pub struct BindImageMemorySwapchainInfoKHR {
20101     pub s_type: StructureType,
20102     pub p_next: *const c_void,
20103     pub swapchain: SwapchainKHR,
20104     pub image_index: u32,
20105 }
20106 impl ::std::default::Default for BindImageMemorySwapchainInfoKHR {
default() -> BindImageMemorySwapchainInfoKHR20107     fn default() -> BindImageMemorySwapchainInfoKHR {
20108         BindImageMemorySwapchainInfoKHR {
20109             s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
20110             p_next: ::std::ptr::null(),
20111             swapchain: SwapchainKHR::default(),
20112             image_index: u32::default(),
20113         }
20114     }
20115 }
20116 impl BindImageMemorySwapchainInfoKHR {
builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a>20117     pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
20118         BindImageMemorySwapchainInfoKHRBuilder {
20119             inner: BindImageMemorySwapchainInfoKHR::default(),
20120             marker: ::std::marker::PhantomData,
20121         }
20122     }
20123 }
20124 #[repr(transparent)]
20125 pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> {
20126     inner: BindImageMemorySwapchainInfoKHR,
20127     marker: ::std::marker::PhantomData<&'a ()>,
20128 }
20129 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {}
20130 unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {}
20131 impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> {
20132     type Target = BindImageMemorySwapchainInfoKHR;
deref(&self) -> &Self::Target20133     fn deref(&self) -> &Self::Target {
20134         &self.inner
20135     }
20136 }
20137 impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20138     fn deref_mut(&mut self) -> &mut Self::Target {
20139         &mut self.inner
20140     }
20141 }
20142 impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
swapchain( mut self, swapchain: SwapchainKHR, ) -> BindImageMemorySwapchainInfoKHRBuilder<'a>20143     pub fn swapchain(
20144         mut self,
20145         swapchain: SwapchainKHR,
20146     ) -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
20147         self.inner.swapchain = swapchain;
20148         self
20149     }
image_index(mut self, image_index: u32) -> BindImageMemorySwapchainInfoKHRBuilder<'a>20150     pub fn image_index(mut self, image_index: u32) -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
20151         self.inner.image_index = image_index;
20152         self
20153     }
20154     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20155     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20156     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImageMemorySwapchainInfoKHR20157     pub fn build(self) -> BindImageMemorySwapchainInfoKHR {
20158         self.inner
20159     }
20160 }
20161 #[repr(C)]
20162 #[derive(Copy, Clone, Debug)]
20163 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireNextImageInfoKHR.html>"]
20164 pub struct AcquireNextImageInfoKHR {
20165     pub s_type: StructureType,
20166     pub p_next: *const c_void,
20167     pub swapchain: SwapchainKHR,
20168     pub timeout: u64,
20169     pub semaphore: Semaphore,
20170     pub fence: Fence,
20171     pub device_mask: u32,
20172 }
20173 impl ::std::default::Default for AcquireNextImageInfoKHR {
default() -> AcquireNextImageInfoKHR20174     fn default() -> AcquireNextImageInfoKHR {
20175         AcquireNextImageInfoKHR {
20176             s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR,
20177             p_next: ::std::ptr::null(),
20178             swapchain: SwapchainKHR::default(),
20179             timeout: u64::default(),
20180             semaphore: Semaphore::default(),
20181             fence: Fence::default(),
20182             device_mask: u32::default(),
20183         }
20184     }
20185 }
20186 impl AcquireNextImageInfoKHR {
builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a>20187     pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> {
20188         AcquireNextImageInfoKHRBuilder {
20189             inner: AcquireNextImageInfoKHR::default(),
20190             marker: ::std::marker::PhantomData,
20191         }
20192     }
20193 }
20194 #[repr(transparent)]
20195 pub struct AcquireNextImageInfoKHRBuilder<'a> {
20196     inner: AcquireNextImageInfoKHR,
20197     marker: ::std::marker::PhantomData<&'a ()>,
20198 }
20199 pub unsafe trait ExtendsAcquireNextImageInfoKHR {}
20200 impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> {
20201     type Target = AcquireNextImageInfoKHR;
deref(&self) -> &Self::Target20202     fn deref(&self) -> &Self::Target {
20203         &self.inner
20204     }
20205 }
20206 impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20207     fn deref_mut(&mut self) -> &mut Self::Target {
20208         &mut self.inner
20209     }
20210 }
20211 impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
swapchain(mut self, swapchain: SwapchainKHR) -> AcquireNextImageInfoKHRBuilder<'a>20212     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> AcquireNextImageInfoKHRBuilder<'a> {
20213         self.inner.swapchain = swapchain;
20214         self
20215     }
timeout(mut self, timeout: u64) -> AcquireNextImageInfoKHRBuilder<'a>20216     pub fn timeout(mut self, timeout: u64) -> AcquireNextImageInfoKHRBuilder<'a> {
20217         self.inner.timeout = timeout;
20218         self
20219     }
semaphore(mut self, semaphore: Semaphore) -> AcquireNextImageInfoKHRBuilder<'a>20220     pub fn semaphore(mut self, semaphore: Semaphore) -> AcquireNextImageInfoKHRBuilder<'a> {
20221         self.inner.semaphore = semaphore;
20222         self
20223     }
fence(mut self, fence: Fence) -> AcquireNextImageInfoKHRBuilder<'a>20224     pub fn fence(mut self, fence: Fence) -> AcquireNextImageInfoKHRBuilder<'a> {
20225         self.inner.fence = fence;
20226         self
20227     }
device_mask(mut self, device_mask: u32) -> AcquireNextImageInfoKHRBuilder<'a>20228     pub fn device_mask(mut self, device_mask: u32) -> AcquireNextImageInfoKHRBuilder<'a> {
20229         self.inner.device_mask = device_mask;
20230         self
20231     }
20232     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20233     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20234     #[doc = r" valid extension structs can be pushed into the chain."]
20235     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20236     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAcquireNextImageInfoKHR>( mut self, next: &'a mut T, ) -> AcquireNextImageInfoKHRBuilder<'a>20237     pub fn push_next<T: ExtendsAcquireNextImageInfoKHR>(
20238         mut self,
20239         next: &'a mut T,
20240     ) -> AcquireNextImageInfoKHRBuilder<'a> {
20241         unsafe {
20242             let next_ptr = next as *mut T as *mut BaseOutStructure;
20243             let last_next = ptr_chain_iter(next).last().unwrap();
20244             (*last_next).p_next = self.inner.p_next as _;
20245             self.inner.p_next = next_ptr as _;
20246         }
20247         self
20248     }
20249     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20250     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20251     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AcquireNextImageInfoKHR20252     pub fn build(self) -> AcquireNextImageInfoKHR {
20253         self.inner
20254     }
20255 }
20256 #[repr(C)]
20257 #[derive(Copy, Clone, Debug)]
20258 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentInfoKHR.html>"]
20259 pub struct DeviceGroupPresentInfoKHR {
20260     pub s_type: StructureType,
20261     pub p_next: *const c_void,
20262     pub swapchain_count: u32,
20263     pub p_device_masks: *const u32,
20264     pub mode: DeviceGroupPresentModeFlagsKHR,
20265 }
20266 impl ::std::default::Default for DeviceGroupPresentInfoKHR {
default() -> DeviceGroupPresentInfoKHR20267     fn default() -> DeviceGroupPresentInfoKHR {
20268         DeviceGroupPresentInfoKHR {
20269             s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR,
20270             p_next: ::std::ptr::null(),
20271             swapchain_count: u32::default(),
20272             p_device_masks: ::std::ptr::null(),
20273             mode: DeviceGroupPresentModeFlagsKHR::default(),
20274         }
20275     }
20276 }
20277 impl DeviceGroupPresentInfoKHR {
builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a>20278     pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> {
20279         DeviceGroupPresentInfoKHRBuilder {
20280             inner: DeviceGroupPresentInfoKHR::default(),
20281             marker: ::std::marker::PhantomData,
20282         }
20283     }
20284 }
20285 #[repr(transparent)]
20286 pub struct DeviceGroupPresentInfoKHRBuilder<'a> {
20287     inner: DeviceGroupPresentInfoKHR,
20288     marker: ::std::marker::PhantomData<&'a ()>,
20289 }
20290 unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {}
20291 unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {}
20292 impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> {
20293     type Target = DeviceGroupPresentInfoKHR;
deref(&self) -> &Self::Target20294     fn deref(&self) -> &Self::Target {
20295         &self.inner
20296     }
20297 }
20298 impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20299     fn deref_mut(&mut self) -> &mut Self::Target {
20300         &mut self.inner
20301     }
20302 }
20303 impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
device_masks(mut self, device_masks: &'a [u32]) -> DeviceGroupPresentInfoKHRBuilder<'a>20304     pub fn device_masks(mut self, device_masks: &'a [u32]) -> DeviceGroupPresentInfoKHRBuilder<'a> {
20305         self.inner.swapchain_count = device_masks.len() as _;
20306         self.inner.p_device_masks = device_masks.as_ptr();
20307         self
20308     }
mode( mut self, mode: DeviceGroupPresentModeFlagsKHR, ) -> DeviceGroupPresentInfoKHRBuilder<'a>20309     pub fn mode(
20310         mut self,
20311         mode: DeviceGroupPresentModeFlagsKHR,
20312     ) -> DeviceGroupPresentInfoKHRBuilder<'a> {
20313         self.inner.mode = mode;
20314         self
20315     }
20316     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20317     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20318     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupPresentInfoKHR20319     pub fn build(self) -> DeviceGroupPresentInfoKHR {
20320         self.inner
20321     }
20322 }
20323 #[repr(C)]
20324 #[derive(Copy, Clone, Debug)]
20325 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html>"]
20326 pub struct DeviceGroupDeviceCreateInfo {
20327     pub s_type: StructureType,
20328     pub p_next: *const c_void,
20329     pub physical_device_count: u32,
20330     pub p_physical_devices: *const PhysicalDevice,
20331 }
20332 impl ::std::default::Default for DeviceGroupDeviceCreateInfo {
default() -> DeviceGroupDeviceCreateInfo20333     fn default() -> DeviceGroupDeviceCreateInfo {
20334         DeviceGroupDeviceCreateInfo {
20335             s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO,
20336             p_next: ::std::ptr::null(),
20337             physical_device_count: u32::default(),
20338             p_physical_devices: ::std::ptr::null(),
20339         }
20340     }
20341 }
20342 impl DeviceGroupDeviceCreateInfo {
builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a>20343     pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> {
20344         DeviceGroupDeviceCreateInfoBuilder {
20345             inner: DeviceGroupDeviceCreateInfo::default(),
20346             marker: ::std::marker::PhantomData,
20347         }
20348     }
20349 }
20350 #[repr(transparent)]
20351 pub struct DeviceGroupDeviceCreateInfoBuilder<'a> {
20352     inner: DeviceGroupDeviceCreateInfo,
20353     marker: ::std::marker::PhantomData<&'a ()>,
20354 }
20355 unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {}
20356 unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {}
20357 impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> {
20358     type Target = DeviceGroupDeviceCreateInfo;
deref(&self) -> &Self::Target20359     fn deref(&self) -> &Self::Target {
20360         &self.inner
20361     }
20362 }
20363 impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20364     fn deref_mut(&mut self) -> &mut Self::Target {
20365         &mut self.inner
20366     }
20367 }
20368 impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
physical_devices( mut self, physical_devices: &'a [PhysicalDevice], ) -> DeviceGroupDeviceCreateInfoBuilder<'a>20369     pub fn physical_devices(
20370         mut self,
20371         physical_devices: &'a [PhysicalDevice],
20372     ) -> DeviceGroupDeviceCreateInfoBuilder<'a> {
20373         self.inner.physical_device_count = physical_devices.len() as _;
20374         self.inner.p_physical_devices = physical_devices.as_ptr();
20375         self
20376     }
20377     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20378     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20379     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupDeviceCreateInfo20380     pub fn build(self) -> DeviceGroupDeviceCreateInfo {
20381         self.inner
20382     }
20383 }
20384 #[repr(C)]
20385 #[derive(Copy, Clone, Debug)]
20386 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>"]
20387 pub struct DeviceGroupSwapchainCreateInfoKHR {
20388     pub s_type: StructureType,
20389     pub p_next: *const c_void,
20390     pub modes: DeviceGroupPresentModeFlagsKHR,
20391 }
20392 impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR {
default() -> DeviceGroupSwapchainCreateInfoKHR20393     fn default() -> DeviceGroupSwapchainCreateInfoKHR {
20394         DeviceGroupSwapchainCreateInfoKHR {
20395             s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
20396             p_next: ::std::ptr::null(),
20397             modes: DeviceGroupPresentModeFlagsKHR::default(),
20398         }
20399     }
20400 }
20401 impl DeviceGroupSwapchainCreateInfoKHR {
builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a>20402     pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20403         DeviceGroupSwapchainCreateInfoKHRBuilder {
20404             inner: DeviceGroupSwapchainCreateInfoKHR::default(),
20405             marker: ::std::marker::PhantomData,
20406         }
20407     }
20408 }
20409 #[repr(transparent)]
20410 pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20411     inner: DeviceGroupSwapchainCreateInfoKHR,
20412     marker: ::std::marker::PhantomData<&'a ()>,
20413 }
20414 unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {}
20415 unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {}
20416 impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20417     type Target = DeviceGroupSwapchainCreateInfoKHR;
deref(&self) -> &Self::Target20418     fn deref(&self) -> &Self::Target {
20419         &self.inner
20420     }
20421 }
20422 impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20423     fn deref_mut(&mut self) -> &mut Self::Target {
20424         &mut self.inner
20425     }
20426 }
20427 impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
modes( mut self, modes: DeviceGroupPresentModeFlagsKHR, ) -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a>20428     pub fn modes(
20429         mut self,
20430         modes: DeviceGroupPresentModeFlagsKHR,
20431     ) -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
20432         self.inner.modes = modes;
20433         self
20434     }
20435     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20436     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20437     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceGroupSwapchainCreateInfoKHR20438     pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR {
20439         self.inner
20440     }
20441 }
20442 #[repr(C)]
20443 #[derive(Copy, Clone, Default, Debug)]
20444 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateEntry.html>"]
20445 pub struct DescriptorUpdateTemplateEntry {
20446     pub dst_binding: u32,
20447     pub dst_array_element: u32,
20448     pub descriptor_count: u32,
20449     pub descriptor_type: DescriptorType,
20450     pub offset: usize,
20451     pub stride: usize,
20452 }
20453 impl DescriptorUpdateTemplateEntry {
builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a>20454     pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> {
20455         DescriptorUpdateTemplateEntryBuilder {
20456             inner: DescriptorUpdateTemplateEntry::default(),
20457             marker: ::std::marker::PhantomData,
20458         }
20459     }
20460 }
20461 #[repr(transparent)]
20462 pub struct DescriptorUpdateTemplateEntryBuilder<'a> {
20463     inner: DescriptorUpdateTemplateEntry,
20464     marker: ::std::marker::PhantomData<&'a ()>,
20465 }
20466 impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> {
20467     type Target = DescriptorUpdateTemplateEntry;
deref(&self) -> &Self::Target20468     fn deref(&self) -> &Self::Target {
20469         &self.inner
20470     }
20471 }
20472 impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20473     fn deref_mut(&mut self) -> &mut Self::Target {
20474         &mut self.inner
20475     }
20476 }
20477 impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> {
dst_binding(mut self, dst_binding: u32) -> DescriptorUpdateTemplateEntryBuilder<'a>20478     pub fn dst_binding(mut self, dst_binding: u32) -> DescriptorUpdateTemplateEntryBuilder<'a> {
20479         self.inner.dst_binding = dst_binding;
20480         self
20481     }
dst_array_element( mut self, dst_array_element: u32, ) -> DescriptorUpdateTemplateEntryBuilder<'a>20482     pub fn dst_array_element(
20483         mut self,
20484         dst_array_element: u32,
20485     ) -> DescriptorUpdateTemplateEntryBuilder<'a> {
20486         self.inner.dst_array_element = dst_array_element;
20487         self
20488     }
descriptor_count( mut self, descriptor_count: u32, ) -> DescriptorUpdateTemplateEntryBuilder<'a>20489     pub fn descriptor_count(
20490         mut self,
20491         descriptor_count: u32,
20492     ) -> DescriptorUpdateTemplateEntryBuilder<'a> {
20493         self.inner.descriptor_count = descriptor_count;
20494         self
20495     }
descriptor_type( mut self, descriptor_type: DescriptorType, ) -> DescriptorUpdateTemplateEntryBuilder<'a>20496     pub fn descriptor_type(
20497         mut self,
20498         descriptor_type: DescriptorType,
20499     ) -> DescriptorUpdateTemplateEntryBuilder<'a> {
20500         self.inner.descriptor_type = descriptor_type;
20501         self
20502     }
offset(mut self, offset: usize) -> DescriptorUpdateTemplateEntryBuilder<'a>20503     pub fn offset(mut self, offset: usize) -> DescriptorUpdateTemplateEntryBuilder<'a> {
20504         self.inner.offset = offset;
20505         self
20506     }
stride(mut self, stride: usize) -> DescriptorUpdateTemplateEntryBuilder<'a>20507     pub fn stride(mut self, stride: usize) -> DescriptorUpdateTemplateEntryBuilder<'a> {
20508         self.inner.stride = stride;
20509         self
20510     }
20511     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20512     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20513     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorUpdateTemplateEntry20514     pub fn build(self) -> DescriptorUpdateTemplateEntry {
20515         self.inner
20516     }
20517 }
20518 #[repr(C)]
20519 #[derive(Copy, Clone, Debug)]
20520 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html>"]
20521 pub struct DescriptorUpdateTemplateCreateInfo {
20522     pub s_type: StructureType,
20523     pub p_next: *const c_void,
20524     pub flags: DescriptorUpdateTemplateCreateFlags,
20525     pub descriptor_update_entry_count: u32,
20526     pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry,
20527     pub template_type: DescriptorUpdateTemplateType,
20528     pub descriptor_set_layout: DescriptorSetLayout,
20529     pub pipeline_bind_point: PipelineBindPoint,
20530     pub pipeline_layout: PipelineLayout,
20531     pub set: u32,
20532 }
20533 impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo {
default() -> DescriptorUpdateTemplateCreateInfo20534     fn default() -> DescriptorUpdateTemplateCreateInfo {
20535         DescriptorUpdateTemplateCreateInfo {
20536             s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
20537             p_next: ::std::ptr::null(),
20538             flags: DescriptorUpdateTemplateCreateFlags::default(),
20539             descriptor_update_entry_count: u32::default(),
20540             p_descriptor_update_entries: ::std::ptr::null(),
20541             template_type: DescriptorUpdateTemplateType::default(),
20542             descriptor_set_layout: DescriptorSetLayout::default(),
20543             pipeline_bind_point: PipelineBindPoint::default(),
20544             pipeline_layout: PipelineLayout::default(),
20545             set: u32::default(),
20546         }
20547     }
20548 }
20549 impl DescriptorUpdateTemplateCreateInfo {
builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20550     pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20551         DescriptorUpdateTemplateCreateInfoBuilder {
20552             inner: DescriptorUpdateTemplateCreateInfo::default(),
20553             marker: ::std::marker::PhantomData,
20554         }
20555     }
20556 }
20557 #[repr(transparent)]
20558 pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20559     inner: DescriptorUpdateTemplateCreateInfo,
20560     marker: ::std::marker::PhantomData<&'a ()>,
20561 }
20562 pub unsafe trait ExtendsDescriptorUpdateTemplateCreateInfo {}
20563 impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20564     type Target = DescriptorUpdateTemplateCreateInfo;
deref(&self) -> &Self::Target20565     fn deref(&self) -> &Self::Target {
20566         &self.inner
20567     }
20568 }
20569 impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20570     fn deref_mut(&mut self) -> &mut Self::Target {
20571         &mut self.inner
20572     }
20573 }
20574 impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
flags( mut self, flags: DescriptorUpdateTemplateCreateFlags, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20575     pub fn flags(
20576         mut self,
20577         flags: DescriptorUpdateTemplateCreateFlags,
20578     ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20579         self.inner.flags = flags;
20580         self
20581     }
descriptor_update_entries( mut self, descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry], ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20582     pub fn descriptor_update_entries(
20583         mut self,
20584         descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry],
20585     ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20586         self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _;
20587         self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr();
20588         self
20589     }
template_type( mut self, template_type: DescriptorUpdateTemplateType, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20590     pub fn template_type(
20591         mut self,
20592         template_type: DescriptorUpdateTemplateType,
20593     ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20594         self.inner.template_type = template_type;
20595         self
20596     }
descriptor_set_layout( mut self, descriptor_set_layout: DescriptorSetLayout, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20597     pub fn descriptor_set_layout(
20598         mut self,
20599         descriptor_set_layout: DescriptorSetLayout,
20600     ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20601         self.inner.descriptor_set_layout = descriptor_set_layout;
20602         self
20603     }
pipeline_bind_point( mut self, pipeline_bind_point: PipelineBindPoint, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20604     pub fn pipeline_bind_point(
20605         mut self,
20606         pipeline_bind_point: PipelineBindPoint,
20607     ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20608         self.inner.pipeline_bind_point = pipeline_bind_point;
20609         self
20610     }
pipeline_layout( mut self, pipeline_layout: PipelineLayout, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20611     pub fn pipeline_layout(
20612         mut self,
20613         pipeline_layout: PipelineLayout,
20614     ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20615         self.inner.pipeline_layout = pipeline_layout;
20616         self
20617     }
set(mut self, set: u32) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20618     pub fn set(mut self, set: u32) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20619         self.inner.set = set;
20620         self
20621     }
20622     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20623     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20624     #[doc = r" valid extension structs can be pushed into the chain."]
20625     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20626     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorUpdateTemplateCreateInfo>( mut self, next: &'a mut T, ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a>20627     pub fn push_next<T: ExtendsDescriptorUpdateTemplateCreateInfo>(
20628         mut self,
20629         next: &'a mut T,
20630     ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
20631         unsafe {
20632             let next_ptr = next as *mut T as *mut BaseOutStructure;
20633             let last_next = ptr_chain_iter(next).last().unwrap();
20634             (*last_next).p_next = self.inner.p_next as _;
20635             self.inner.p_next = next_ptr as _;
20636         }
20637         self
20638     }
20639     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20640     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20641     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorUpdateTemplateCreateInfo20642     pub fn build(self) -> DescriptorUpdateTemplateCreateInfo {
20643         self.inner
20644     }
20645 }
20646 #[repr(C)]
20647 #[derive(Copy, Clone, Default, Debug)]
20648 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXYColorEXT.html>"]
20649 pub struct XYColorEXT {
20650     pub x: f32,
20651     pub y: f32,
20652 }
20653 impl XYColorEXT {
builder<'a>() -> XYColorEXTBuilder<'a>20654     pub fn builder<'a>() -> XYColorEXTBuilder<'a> {
20655         XYColorEXTBuilder {
20656             inner: XYColorEXT::default(),
20657             marker: ::std::marker::PhantomData,
20658         }
20659     }
20660 }
20661 #[repr(transparent)]
20662 pub struct XYColorEXTBuilder<'a> {
20663     inner: XYColorEXT,
20664     marker: ::std::marker::PhantomData<&'a ()>,
20665 }
20666 impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> {
20667     type Target = XYColorEXT;
deref(&self) -> &Self::Target20668     fn deref(&self) -> &Self::Target {
20669         &self.inner
20670     }
20671 }
20672 impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20673     fn deref_mut(&mut self) -> &mut Self::Target {
20674         &mut self.inner
20675     }
20676 }
20677 impl<'a> XYColorEXTBuilder<'a> {
x(mut self, x: f32) -> XYColorEXTBuilder<'a>20678     pub fn x(mut self, x: f32) -> XYColorEXTBuilder<'a> {
20679         self.inner.x = x;
20680         self
20681     }
y(mut self, y: f32) -> XYColorEXTBuilder<'a>20682     pub fn y(mut self, y: f32) -> XYColorEXTBuilder<'a> {
20683         self.inner.y = y;
20684         self
20685     }
20686     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20687     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20688     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> XYColorEXT20689     pub fn build(self) -> XYColorEXT {
20690         self.inner
20691     }
20692 }
20693 #[repr(C)]
20694 #[derive(Copy, Clone, Debug)]
20695 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHdrMetadataEXT.html>"]
20696 pub struct HdrMetadataEXT {
20697     pub s_type: StructureType,
20698     pub p_next: *const c_void,
20699     pub display_primary_red: XYColorEXT,
20700     pub display_primary_green: XYColorEXT,
20701     pub display_primary_blue: XYColorEXT,
20702     pub white_point: XYColorEXT,
20703     pub max_luminance: f32,
20704     pub min_luminance: f32,
20705     pub max_content_light_level: f32,
20706     pub max_frame_average_light_level: f32,
20707 }
20708 impl ::std::default::Default for HdrMetadataEXT {
default() -> HdrMetadataEXT20709     fn default() -> HdrMetadataEXT {
20710         HdrMetadataEXT {
20711             s_type: StructureType::HDR_METADATA_EXT,
20712             p_next: ::std::ptr::null(),
20713             display_primary_red: XYColorEXT::default(),
20714             display_primary_green: XYColorEXT::default(),
20715             display_primary_blue: XYColorEXT::default(),
20716             white_point: XYColorEXT::default(),
20717             max_luminance: f32::default(),
20718             min_luminance: f32::default(),
20719             max_content_light_level: f32::default(),
20720             max_frame_average_light_level: f32::default(),
20721         }
20722     }
20723 }
20724 impl HdrMetadataEXT {
builder<'a>() -> HdrMetadataEXTBuilder<'a>20725     pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> {
20726         HdrMetadataEXTBuilder {
20727             inner: HdrMetadataEXT::default(),
20728             marker: ::std::marker::PhantomData,
20729         }
20730     }
20731 }
20732 #[repr(transparent)]
20733 pub struct HdrMetadataEXTBuilder<'a> {
20734     inner: HdrMetadataEXT,
20735     marker: ::std::marker::PhantomData<&'a ()>,
20736 }
20737 pub unsafe trait ExtendsHdrMetadataEXT {}
20738 impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> {
20739     type Target = HdrMetadataEXT;
deref(&self) -> &Self::Target20740     fn deref(&self) -> &Self::Target {
20741         &self.inner
20742     }
20743 }
20744 impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20745     fn deref_mut(&mut self) -> &mut Self::Target {
20746         &mut self.inner
20747     }
20748 }
20749 impl<'a> HdrMetadataEXTBuilder<'a> {
display_primary_red( mut self, display_primary_red: XYColorEXT, ) -> HdrMetadataEXTBuilder<'a>20750     pub fn display_primary_red(
20751         mut self,
20752         display_primary_red: XYColorEXT,
20753     ) -> HdrMetadataEXTBuilder<'a> {
20754         self.inner.display_primary_red = display_primary_red;
20755         self
20756     }
display_primary_green( mut self, display_primary_green: XYColorEXT, ) -> HdrMetadataEXTBuilder<'a>20757     pub fn display_primary_green(
20758         mut self,
20759         display_primary_green: XYColorEXT,
20760     ) -> HdrMetadataEXTBuilder<'a> {
20761         self.inner.display_primary_green = display_primary_green;
20762         self
20763     }
display_primary_blue( mut self, display_primary_blue: XYColorEXT, ) -> HdrMetadataEXTBuilder<'a>20764     pub fn display_primary_blue(
20765         mut self,
20766         display_primary_blue: XYColorEXT,
20767     ) -> HdrMetadataEXTBuilder<'a> {
20768         self.inner.display_primary_blue = display_primary_blue;
20769         self
20770     }
white_point(mut self, white_point: XYColorEXT) -> HdrMetadataEXTBuilder<'a>20771     pub fn white_point(mut self, white_point: XYColorEXT) -> HdrMetadataEXTBuilder<'a> {
20772         self.inner.white_point = white_point;
20773         self
20774     }
max_luminance(mut self, max_luminance: f32) -> HdrMetadataEXTBuilder<'a>20775     pub fn max_luminance(mut self, max_luminance: f32) -> HdrMetadataEXTBuilder<'a> {
20776         self.inner.max_luminance = max_luminance;
20777         self
20778     }
min_luminance(mut self, min_luminance: f32) -> HdrMetadataEXTBuilder<'a>20779     pub fn min_luminance(mut self, min_luminance: f32) -> HdrMetadataEXTBuilder<'a> {
20780         self.inner.min_luminance = min_luminance;
20781         self
20782     }
max_content_light_level( mut self, max_content_light_level: f32, ) -> HdrMetadataEXTBuilder<'a>20783     pub fn max_content_light_level(
20784         mut self,
20785         max_content_light_level: f32,
20786     ) -> HdrMetadataEXTBuilder<'a> {
20787         self.inner.max_content_light_level = max_content_light_level;
20788         self
20789     }
max_frame_average_light_level( mut self, max_frame_average_light_level: f32, ) -> HdrMetadataEXTBuilder<'a>20790     pub fn max_frame_average_light_level(
20791         mut self,
20792         max_frame_average_light_level: f32,
20793     ) -> HdrMetadataEXTBuilder<'a> {
20794         self.inner.max_frame_average_light_level = max_frame_average_light_level;
20795         self
20796     }
20797     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
20798     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
20799     #[doc = r" valid extension structs can be pushed into the chain."]
20800     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
20801     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsHdrMetadataEXT>( mut self, next: &'a mut T, ) -> HdrMetadataEXTBuilder<'a>20802     pub fn push_next<T: ExtendsHdrMetadataEXT>(
20803         mut self,
20804         next: &'a mut T,
20805     ) -> HdrMetadataEXTBuilder<'a> {
20806         unsafe {
20807             let next_ptr = next as *mut T as *mut BaseOutStructure;
20808             let last_next = ptr_chain_iter(next).last().unwrap();
20809             (*last_next).p_next = self.inner.p_next as _;
20810             self.inner.p_next = next_ptr as _;
20811         }
20812         self
20813     }
20814     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20815     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20816     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> HdrMetadataEXT20817     pub fn build(self) -> HdrMetadataEXT {
20818         self.inner
20819     }
20820 }
20821 #[repr(C)]
20822 #[derive(Copy, Clone, Debug)]
20823 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>"]
20824 pub struct DisplayNativeHdrSurfaceCapabilitiesAMD {
20825     pub s_type: StructureType,
20826     pub p_next: *mut c_void,
20827     pub local_dimming_support: Bool32,
20828 }
20829 impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD {
default() -> DisplayNativeHdrSurfaceCapabilitiesAMD20830     fn default() -> DisplayNativeHdrSurfaceCapabilitiesAMD {
20831         DisplayNativeHdrSurfaceCapabilitiesAMD {
20832             s_type: StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
20833             p_next: ::std::ptr::null_mut(),
20834             local_dimming_support: Bool32::default(),
20835         }
20836     }
20837 }
20838 impl DisplayNativeHdrSurfaceCapabilitiesAMD {
builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a>20839     pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
20840         DisplayNativeHdrSurfaceCapabilitiesAMDBuilder {
20841             inner: DisplayNativeHdrSurfaceCapabilitiesAMD::default(),
20842             marker: ::std::marker::PhantomData,
20843         }
20844     }
20845 }
20846 #[repr(transparent)]
20847 pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
20848     inner: DisplayNativeHdrSurfaceCapabilitiesAMD,
20849     marker: ::std::marker::PhantomData<&'a ()>,
20850 }
20851 unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {}
20852 unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {}
20853 impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
20854     type Target = DisplayNativeHdrSurfaceCapabilitiesAMD;
deref(&self) -> &Self::Target20855     fn deref(&self) -> &Self::Target {
20856         &self.inner
20857     }
20858 }
20859 impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20860     fn deref_mut(&mut self) -> &mut Self::Target {
20861         &mut self.inner
20862     }
20863 }
20864 impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
local_dimming_support( mut self, local_dimming_support: bool, ) -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a>20865     pub fn local_dimming_support(
20866         mut self,
20867         local_dimming_support: bool,
20868     ) -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
20869         self.inner.local_dimming_support = local_dimming_support.into();
20870         self
20871     }
20872     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20873     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20874     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD20875     pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD {
20876         self.inner
20877     }
20878 }
20879 #[repr(C)]
20880 #[derive(Copy, Clone, Debug)]
20881 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>"]
20882 pub struct SwapchainDisplayNativeHdrCreateInfoAMD {
20883     pub s_type: StructureType,
20884     pub p_next: *const c_void,
20885     pub local_dimming_enable: Bool32,
20886 }
20887 impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD {
default() -> SwapchainDisplayNativeHdrCreateInfoAMD20888     fn default() -> SwapchainDisplayNativeHdrCreateInfoAMD {
20889         SwapchainDisplayNativeHdrCreateInfoAMD {
20890             s_type: StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
20891             p_next: ::std::ptr::null(),
20892             local_dimming_enable: Bool32::default(),
20893         }
20894     }
20895 }
20896 impl SwapchainDisplayNativeHdrCreateInfoAMD {
builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a>20897     pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
20898         SwapchainDisplayNativeHdrCreateInfoAMDBuilder {
20899             inner: SwapchainDisplayNativeHdrCreateInfoAMD::default(),
20900             marker: ::std::marker::PhantomData,
20901         }
20902     }
20903 }
20904 #[repr(transparent)]
20905 pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
20906     inner: SwapchainDisplayNativeHdrCreateInfoAMD,
20907     marker: ::std::marker::PhantomData<&'a ()>,
20908 }
20909 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {}
20910 unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {}
20911 impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
20912     type Target = SwapchainDisplayNativeHdrCreateInfoAMD;
deref(&self) -> &Self::Target20913     fn deref(&self) -> &Self::Target {
20914         &self.inner
20915     }
20916 }
20917 impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20918     fn deref_mut(&mut self) -> &mut Self::Target {
20919         &mut self.inner
20920     }
20921 }
20922 impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
local_dimming_enable( mut self, local_dimming_enable: bool, ) -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a>20923     pub fn local_dimming_enable(
20924         mut self,
20925         local_dimming_enable: bool,
20926     ) -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
20927         self.inner.local_dimming_enable = local_dimming_enable.into();
20928         self
20929     }
20930     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20931     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20932     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD20933     pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD {
20934         self.inner
20935     }
20936 }
20937 #[repr(C)]
20938 #[derive(Copy, Clone, Default, Debug)]
20939 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRefreshCycleDurationGOOGLE.html>"]
20940 pub struct RefreshCycleDurationGOOGLE {
20941     pub refresh_duration: u64,
20942 }
20943 impl RefreshCycleDurationGOOGLE {
builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a>20944     pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> {
20945         RefreshCycleDurationGOOGLEBuilder {
20946             inner: RefreshCycleDurationGOOGLE::default(),
20947             marker: ::std::marker::PhantomData,
20948         }
20949     }
20950 }
20951 #[repr(transparent)]
20952 pub struct RefreshCycleDurationGOOGLEBuilder<'a> {
20953     inner: RefreshCycleDurationGOOGLE,
20954     marker: ::std::marker::PhantomData<&'a ()>,
20955 }
20956 impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> {
20957     type Target = RefreshCycleDurationGOOGLE;
deref(&self) -> &Self::Target20958     fn deref(&self) -> &Self::Target {
20959         &self.inner
20960     }
20961 }
20962 impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target20963     fn deref_mut(&mut self) -> &mut Self::Target {
20964         &mut self.inner
20965     }
20966 }
20967 impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> {
refresh_duration( mut self, refresh_duration: u64, ) -> RefreshCycleDurationGOOGLEBuilder<'a>20968     pub fn refresh_duration(
20969         mut self,
20970         refresh_duration: u64,
20971     ) -> RefreshCycleDurationGOOGLEBuilder<'a> {
20972         self.inner.refresh_duration = refresh_duration;
20973         self
20974     }
20975     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
20976     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
20977     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RefreshCycleDurationGOOGLE20978     pub fn build(self) -> RefreshCycleDurationGOOGLE {
20979         self.inner
20980     }
20981 }
20982 #[repr(C)]
20983 #[derive(Copy, Clone, Default, Debug)]
20984 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPastPresentationTimingGOOGLE.html>"]
20985 pub struct PastPresentationTimingGOOGLE {
20986     pub present_id: u32,
20987     pub desired_present_time: u64,
20988     pub actual_present_time: u64,
20989     pub earliest_present_time: u64,
20990     pub present_margin: u64,
20991 }
20992 impl PastPresentationTimingGOOGLE {
builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a>20993     pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> {
20994         PastPresentationTimingGOOGLEBuilder {
20995             inner: PastPresentationTimingGOOGLE::default(),
20996             marker: ::std::marker::PhantomData,
20997         }
20998     }
20999 }
21000 #[repr(transparent)]
21001 pub struct PastPresentationTimingGOOGLEBuilder<'a> {
21002     inner: PastPresentationTimingGOOGLE,
21003     marker: ::std::marker::PhantomData<&'a ()>,
21004 }
21005 impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> {
21006     type Target = PastPresentationTimingGOOGLE;
deref(&self) -> &Self::Target21007     fn deref(&self) -> &Self::Target {
21008         &self.inner
21009     }
21010 }
21011 impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21012     fn deref_mut(&mut self) -> &mut Self::Target {
21013         &mut self.inner
21014     }
21015 }
21016 impl<'a> PastPresentationTimingGOOGLEBuilder<'a> {
present_id(mut self, present_id: u32) -> PastPresentationTimingGOOGLEBuilder<'a>21017     pub fn present_id(mut self, present_id: u32) -> PastPresentationTimingGOOGLEBuilder<'a> {
21018         self.inner.present_id = present_id;
21019         self
21020     }
desired_present_time( mut self, desired_present_time: u64, ) -> PastPresentationTimingGOOGLEBuilder<'a>21021     pub fn desired_present_time(
21022         mut self,
21023         desired_present_time: u64,
21024     ) -> PastPresentationTimingGOOGLEBuilder<'a> {
21025         self.inner.desired_present_time = desired_present_time;
21026         self
21027     }
actual_present_time( mut self, actual_present_time: u64, ) -> PastPresentationTimingGOOGLEBuilder<'a>21028     pub fn actual_present_time(
21029         mut self,
21030         actual_present_time: u64,
21031     ) -> PastPresentationTimingGOOGLEBuilder<'a> {
21032         self.inner.actual_present_time = actual_present_time;
21033         self
21034     }
earliest_present_time( mut self, earliest_present_time: u64, ) -> PastPresentationTimingGOOGLEBuilder<'a>21035     pub fn earliest_present_time(
21036         mut self,
21037         earliest_present_time: u64,
21038     ) -> PastPresentationTimingGOOGLEBuilder<'a> {
21039         self.inner.earliest_present_time = earliest_present_time;
21040         self
21041     }
present_margin( mut self, present_margin: u64, ) -> PastPresentationTimingGOOGLEBuilder<'a>21042     pub fn present_margin(
21043         mut self,
21044         present_margin: u64,
21045     ) -> PastPresentationTimingGOOGLEBuilder<'a> {
21046         self.inner.present_margin = present_margin;
21047         self
21048     }
21049     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21050     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21051     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PastPresentationTimingGOOGLE21052     pub fn build(self) -> PastPresentationTimingGOOGLE {
21053         self.inner
21054     }
21055 }
21056 #[repr(C)]
21057 #[derive(Copy, Clone, Debug)]
21058 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentTimesInfoGOOGLE.html>"]
21059 pub struct PresentTimesInfoGOOGLE {
21060     pub s_type: StructureType,
21061     pub p_next: *const c_void,
21062     pub swapchain_count: u32,
21063     pub p_times: *const PresentTimeGOOGLE,
21064 }
21065 impl ::std::default::Default for PresentTimesInfoGOOGLE {
default() -> PresentTimesInfoGOOGLE21066     fn default() -> PresentTimesInfoGOOGLE {
21067         PresentTimesInfoGOOGLE {
21068             s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE,
21069             p_next: ::std::ptr::null(),
21070             swapchain_count: u32::default(),
21071             p_times: ::std::ptr::null(),
21072         }
21073     }
21074 }
21075 impl PresentTimesInfoGOOGLE {
builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a>21076     pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> {
21077         PresentTimesInfoGOOGLEBuilder {
21078             inner: PresentTimesInfoGOOGLE::default(),
21079             marker: ::std::marker::PhantomData,
21080         }
21081     }
21082 }
21083 #[repr(transparent)]
21084 pub struct PresentTimesInfoGOOGLEBuilder<'a> {
21085     inner: PresentTimesInfoGOOGLE,
21086     marker: ::std::marker::PhantomData<&'a ()>,
21087 }
21088 unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {}
21089 unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {}
21090 impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> {
21091     type Target = PresentTimesInfoGOOGLE;
deref(&self) -> &Self::Target21092     fn deref(&self) -> &Self::Target {
21093         &self.inner
21094     }
21095 }
21096 impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21097     fn deref_mut(&mut self) -> &mut Self::Target {
21098         &mut self.inner
21099     }
21100 }
21101 impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
times(mut self, times: &'a [PresentTimeGOOGLE]) -> PresentTimesInfoGOOGLEBuilder<'a>21102     pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> PresentTimesInfoGOOGLEBuilder<'a> {
21103         self.inner.swapchain_count = times.len() as _;
21104         self.inner.p_times = times.as_ptr();
21105         self
21106     }
21107     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21108     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21109     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentTimesInfoGOOGLE21110     pub fn build(self) -> PresentTimesInfoGOOGLE {
21111         self.inner
21112     }
21113 }
21114 #[repr(C)]
21115 #[derive(Copy, Clone, Default, Debug)]
21116 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentTimeGOOGLE.html>"]
21117 pub struct PresentTimeGOOGLE {
21118     pub present_id: u32,
21119     pub desired_present_time: u64,
21120 }
21121 impl PresentTimeGOOGLE {
builder<'a>() -> PresentTimeGOOGLEBuilder<'a>21122     pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> {
21123         PresentTimeGOOGLEBuilder {
21124             inner: PresentTimeGOOGLE::default(),
21125             marker: ::std::marker::PhantomData,
21126         }
21127     }
21128 }
21129 #[repr(transparent)]
21130 pub struct PresentTimeGOOGLEBuilder<'a> {
21131     inner: PresentTimeGOOGLE,
21132     marker: ::std::marker::PhantomData<&'a ()>,
21133 }
21134 impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> {
21135     type Target = PresentTimeGOOGLE;
deref(&self) -> &Self::Target21136     fn deref(&self) -> &Self::Target {
21137         &self.inner
21138     }
21139 }
21140 impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21141     fn deref_mut(&mut self) -> &mut Self::Target {
21142         &mut self.inner
21143     }
21144 }
21145 impl<'a> PresentTimeGOOGLEBuilder<'a> {
present_id(mut self, present_id: u32) -> PresentTimeGOOGLEBuilder<'a>21146     pub fn present_id(mut self, present_id: u32) -> PresentTimeGOOGLEBuilder<'a> {
21147         self.inner.present_id = present_id;
21148         self
21149     }
desired_present_time( mut self, desired_present_time: u64, ) -> PresentTimeGOOGLEBuilder<'a>21150     pub fn desired_present_time(
21151         mut self,
21152         desired_present_time: u64,
21153     ) -> PresentTimeGOOGLEBuilder<'a> {
21154         self.inner.desired_present_time = desired_present_time;
21155         self
21156     }
21157     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21158     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21159     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentTimeGOOGLE21160     pub fn build(self) -> PresentTimeGOOGLE {
21161         self.inner
21162     }
21163 }
21164 #[repr(C)]
21165 #[derive(Copy, Clone, Debug)]
21166 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateInfoMVK.html>"]
21167 pub struct IOSSurfaceCreateInfoMVK {
21168     pub s_type: StructureType,
21169     pub p_next: *const c_void,
21170     pub flags: IOSSurfaceCreateFlagsMVK,
21171     pub p_view: *const c_void,
21172 }
21173 impl ::std::default::Default for IOSSurfaceCreateInfoMVK {
default() -> IOSSurfaceCreateInfoMVK21174     fn default() -> IOSSurfaceCreateInfoMVK {
21175         IOSSurfaceCreateInfoMVK {
21176             s_type: StructureType::IOS_SURFACE_CREATE_INFO_MVK,
21177             p_next: ::std::ptr::null(),
21178             flags: IOSSurfaceCreateFlagsMVK::default(),
21179             p_view: ::std::ptr::null(),
21180         }
21181     }
21182 }
21183 impl IOSSurfaceCreateInfoMVK {
builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a>21184     pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> {
21185         IOSSurfaceCreateInfoMVKBuilder {
21186             inner: IOSSurfaceCreateInfoMVK::default(),
21187             marker: ::std::marker::PhantomData,
21188         }
21189     }
21190 }
21191 #[repr(transparent)]
21192 pub struct IOSSurfaceCreateInfoMVKBuilder<'a> {
21193     inner: IOSSurfaceCreateInfoMVK,
21194     marker: ::std::marker::PhantomData<&'a ()>,
21195 }
21196 pub unsafe trait ExtendsIOSSurfaceCreateInfoMVK {}
21197 impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> {
21198     type Target = IOSSurfaceCreateInfoMVK;
deref(&self) -> &Self::Target21199     fn deref(&self) -> &Self::Target {
21200         &self.inner
21201     }
21202 }
21203 impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21204     fn deref_mut(&mut self) -> &mut Self::Target {
21205         &mut self.inner
21206     }
21207 }
21208 impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> IOSSurfaceCreateInfoMVKBuilder<'a>21209     pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> IOSSurfaceCreateInfoMVKBuilder<'a> {
21210         self.inner.flags = flags;
21211         self
21212     }
view(mut self, view: *const c_void) -> IOSSurfaceCreateInfoMVKBuilder<'a>21213     pub fn view(mut self, view: *const c_void) -> IOSSurfaceCreateInfoMVKBuilder<'a> {
21214         self.inner.p_view = view;
21215         self
21216     }
21217     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21218     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21219     #[doc = r" valid extension structs can be pushed into the chain."]
21220     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21221     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsIOSSurfaceCreateInfoMVK>( mut self, next: &'a mut T, ) -> IOSSurfaceCreateInfoMVKBuilder<'a>21222     pub fn push_next<T: ExtendsIOSSurfaceCreateInfoMVK>(
21223         mut self,
21224         next: &'a mut T,
21225     ) -> IOSSurfaceCreateInfoMVKBuilder<'a> {
21226         unsafe {
21227             let next_ptr = next as *mut T as *mut BaseOutStructure;
21228             let last_next = ptr_chain_iter(next).last().unwrap();
21229             (*last_next).p_next = self.inner.p_next as _;
21230             self.inner.p_next = next_ptr as _;
21231         }
21232         self
21233     }
21234     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21235     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21236     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> IOSSurfaceCreateInfoMVK21237     pub fn build(self) -> IOSSurfaceCreateInfoMVK {
21238         self.inner
21239     }
21240 }
21241 #[repr(C)]
21242 #[derive(Copy, Clone, Debug)]
21243 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html>"]
21244 pub struct MacOSSurfaceCreateInfoMVK {
21245     pub s_type: StructureType,
21246     pub p_next: *const c_void,
21247     pub flags: MacOSSurfaceCreateFlagsMVK,
21248     pub p_view: *const c_void,
21249 }
21250 impl ::std::default::Default for MacOSSurfaceCreateInfoMVK {
default() -> MacOSSurfaceCreateInfoMVK21251     fn default() -> MacOSSurfaceCreateInfoMVK {
21252         MacOSSurfaceCreateInfoMVK {
21253             s_type: StructureType::MACOS_SURFACE_CREATE_INFO_MVK,
21254             p_next: ::std::ptr::null(),
21255             flags: MacOSSurfaceCreateFlagsMVK::default(),
21256             p_view: ::std::ptr::null(),
21257         }
21258     }
21259 }
21260 impl MacOSSurfaceCreateInfoMVK {
builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a>21261     pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
21262         MacOSSurfaceCreateInfoMVKBuilder {
21263             inner: MacOSSurfaceCreateInfoMVK::default(),
21264             marker: ::std::marker::PhantomData,
21265         }
21266     }
21267 }
21268 #[repr(transparent)]
21269 pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> {
21270     inner: MacOSSurfaceCreateInfoMVK,
21271     marker: ::std::marker::PhantomData<&'a ()>,
21272 }
21273 pub unsafe trait ExtendsMacOSSurfaceCreateInfoMVK {}
21274 impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> {
21275     type Target = MacOSSurfaceCreateInfoMVK;
deref(&self) -> &Self::Target21276     fn deref(&self) -> &Self::Target {
21277         &self.inner
21278     }
21279 }
21280 impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21281     fn deref_mut(&mut self) -> &mut Self::Target {
21282         &mut self.inner
21283     }
21284 }
21285 impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
flags( mut self, flags: MacOSSurfaceCreateFlagsMVK, ) -> MacOSSurfaceCreateInfoMVKBuilder<'a>21286     pub fn flags(
21287         mut self,
21288         flags: MacOSSurfaceCreateFlagsMVK,
21289     ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
21290         self.inner.flags = flags;
21291         self
21292     }
view(mut self, view: *const c_void) -> MacOSSurfaceCreateInfoMVKBuilder<'a>21293     pub fn view(mut self, view: *const c_void) -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
21294         self.inner.p_view = view;
21295         self
21296     }
21297     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21298     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21299     #[doc = r" valid extension structs can be pushed into the chain."]
21300     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21301     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMacOSSurfaceCreateInfoMVK>( mut self, next: &'a mut T, ) -> MacOSSurfaceCreateInfoMVKBuilder<'a>21302     pub fn push_next<T: ExtendsMacOSSurfaceCreateInfoMVK>(
21303         mut self,
21304         next: &'a mut T,
21305     ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
21306         unsafe {
21307             let next_ptr = next as *mut T as *mut BaseOutStructure;
21308             let last_next = ptr_chain_iter(next).last().unwrap();
21309             (*last_next).p_next = self.inner.p_next as _;
21310             self.inner.p_next = next_ptr as _;
21311         }
21312         self
21313     }
21314     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21315     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21316     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MacOSSurfaceCreateInfoMVK21317     pub fn build(self) -> MacOSSurfaceCreateInfoMVK {
21318         self.inner
21319     }
21320 }
21321 #[repr(C)]
21322 #[derive(Copy, Clone, Debug)]
21323 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html>"]
21324 pub struct MetalSurfaceCreateInfoEXT {
21325     pub s_type: StructureType,
21326     pub p_next: *const c_void,
21327     pub flags: MetalSurfaceCreateFlagsEXT,
21328     pub p_layer: *const CAMetalLayer,
21329 }
21330 impl ::std::default::Default for MetalSurfaceCreateInfoEXT {
default() -> MetalSurfaceCreateInfoEXT21331     fn default() -> MetalSurfaceCreateInfoEXT {
21332         MetalSurfaceCreateInfoEXT {
21333             s_type: StructureType::METAL_SURFACE_CREATE_INFO_EXT,
21334             p_next: ::std::ptr::null(),
21335             flags: MetalSurfaceCreateFlagsEXT::default(),
21336             p_layer: ::std::ptr::null(),
21337         }
21338     }
21339 }
21340 impl MetalSurfaceCreateInfoEXT {
builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a>21341     pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> {
21342         MetalSurfaceCreateInfoEXTBuilder {
21343             inner: MetalSurfaceCreateInfoEXT::default(),
21344             marker: ::std::marker::PhantomData,
21345         }
21346     }
21347 }
21348 #[repr(transparent)]
21349 pub struct MetalSurfaceCreateInfoEXTBuilder<'a> {
21350     inner: MetalSurfaceCreateInfoEXT,
21351     marker: ::std::marker::PhantomData<&'a ()>,
21352 }
21353 pub unsafe trait ExtendsMetalSurfaceCreateInfoEXT {}
21354 impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> {
21355     type Target = MetalSurfaceCreateInfoEXT;
deref(&self) -> &Self::Target21356     fn deref(&self) -> &Self::Target {
21357         &self.inner
21358     }
21359 }
21360 impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21361     fn deref_mut(&mut self) -> &mut Self::Target {
21362         &mut self.inner
21363     }
21364 }
21365 impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
flags( mut self, flags: MetalSurfaceCreateFlagsEXT, ) -> MetalSurfaceCreateInfoEXTBuilder<'a>21366     pub fn flags(
21367         mut self,
21368         flags: MetalSurfaceCreateFlagsEXT,
21369     ) -> MetalSurfaceCreateInfoEXTBuilder<'a> {
21370         self.inner.flags = flags;
21371         self
21372     }
layer(mut self, layer: *const CAMetalLayer) -> MetalSurfaceCreateInfoEXTBuilder<'a>21373     pub fn layer(mut self, layer: *const CAMetalLayer) -> MetalSurfaceCreateInfoEXTBuilder<'a> {
21374         self.inner.p_layer = layer;
21375         self
21376     }
21377     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
21378     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
21379     #[doc = r" valid extension structs can be pushed into the chain."]
21380     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
21381     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMetalSurfaceCreateInfoEXT>( mut self, next: &'a mut T, ) -> MetalSurfaceCreateInfoEXTBuilder<'a>21382     pub fn push_next<T: ExtendsMetalSurfaceCreateInfoEXT>(
21383         mut self,
21384         next: &'a mut T,
21385     ) -> MetalSurfaceCreateInfoEXTBuilder<'a> {
21386         unsafe {
21387             let next_ptr = next as *mut T as *mut BaseOutStructure;
21388             let last_next = ptr_chain_iter(next).last().unwrap();
21389             (*last_next).p_next = self.inner.p_next as _;
21390             self.inner.p_next = next_ptr as _;
21391         }
21392         self
21393     }
21394     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21395     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21396     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MetalSurfaceCreateInfoEXT21397     pub fn build(self) -> MetalSurfaceCreateInfoEXT {
21398         self.inner
21399     }
21400 }
21401 #[repr(C)]
21402 #[derive(Copy, Clone, Default, Debug)]
21403 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewportWScalingNV.html>"]
21404 pub struct ViewportWScalingNV {
21405     pub xcoeff: f32,
21406     pub ycoeff: f32,
21407 }
21408 impl ViewportWScalingNV {
builder<'a>() -> ViewportWScalingNVBuilder<'a>21409     pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> {
21410         ViewportWScalingNVBuilder {
21411             inner: ViewportWScalingNV::default(),
21412             marker: ::std::marker::PhantomData,
21413         }
21414     }
21415 }
21416 #[repr(transparent)]
21417 pub struct ViewportWScalingNVBuilder<'a> {
21418     inner: ViewportWScalingNV,
21419     marker: ::std::marker::PhantomData<&'a ()>,
21420 }
21421 impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> {
21422     type Target = ViewportWScalingNV;
deref(&self) -> &Self::Target21423     fn deref(&self) -> &Self::Target {
21424         &self.inner
21425     }
21426 }
21427 impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21428     fn deref_mut(&mut self) -> &mut Self::Target {
21429         &mut self.inner
21430     }
21431 }
21432 impl<'a> ViewportWScalingNVBuilder<'a> {
xcoeff(mut self, xcoeff: f32) -> ViewportWScalingNVBuilder<'a>21433     pub fn xcoeff(mut self, xcoeff: f32) -> ViewportWScalingNVBuilder<'a> {
21434         self.inner.xcoeff = xcoeff;
21435         self
21436     }
ycoeff(mut self, ycoeff: f32) -> ViewportWScalingNVBuilder<'a>21437     pub fn ycoeff(mut self, ycoeff: f32) -> ViewportWScalingNVBuilder<'a> {
21438         self.inner.ycoeff = ycoeff;
21439         self
21440     }
21441     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21442     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21443     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ViewportWScalingNV21444     pub fn build(self) -> ViewportWScalingNV {
21445         self.inner
21446     }
21447 }
21448 #[repr(C)]
21449 #[derive(Copy, Clone, Debug)]
21450 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>"]
21451 pub struct PipelineViewportWScalingStateCreateInfoNV {
21452     pub s_type: StructureType,
21453     pub p_next: *const c_void,
21454     pub viewport_w_scaling_enable: Bool32,
21455     pub viewport_count: u32,
21456     pub p_viewport_w_scalings: *const ViewportWScalingNV,
21457 }
21458 impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV {
default() -> PipelineViewportWScalingStateCreateInfoNV21459     fn default() -> PipelineViewportWScalingStateCreateInfoNV {
21460         PipelineViewportWScalingStateCreateInfoNV {
21461             s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
21462             p_next: ::std::ptr::null(),
21463             viewport_w_scaling_enable: Bool32::default(),
21464             viewport_count: u32::default(),
21465             p_viewport_w_scalings: ::std::ptr::null(),
21466         }
21467     }
21468 }
21469 impl PipelineViewportWScalingStateCreateInfoNV {
builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a>21470     pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21471         PipelineViewportWScalingStateCreateInfoNVBuilder {
21472             inner: PipelineViewportWScalingStateCreateInfoNV::default(),
21473             marker: ::std::marker::PhantomData,
21474         }
21475     }
21476 }
21477 #[repr(transparent)]
21478 pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21479     inner: PipelineViewportWScalingStateCreateInfoNV,
21480     marker: ::std::marker::PhantomData<&'a ()>,
21481 }
21482 unsafe impl ExtendsPipelineViewportStateCreateInfo
21483     for PipelineViewportWScalingStateCreateInfoNVBuilder<'_>
21484 {
21485 }
21486 unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {}
21487 impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21488     type Target = PipelineViewportWScalingStateCreateInfoNV;
deref(&self) -> &Self::Target21489     fn deref(&self) -> &Self::Target {
21490         &self.inner
21491     }
21492 }
21493 impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21494     fn deref_mut(&mut self) -> &mut Self::Target {
21495         &mut self.inner
21496     }
21497 }
21498 impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
viewport_w_scaling_enable( mut self, viewport_w_scaling_enable: bool, ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a>21499     pub fn viewport_w_scaling_enable(
21500         mut self,
21501         viewport_w_scaling_enable: bool,
21502     ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21503         self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into();
21504         self
21505     }
viewport_w_scalings( mut self, viewport_w_scalings: &'a [ViewportWScalingNV], ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a>21506     pub fn viewport_w_scalings(
21507         mut self,
21508         viewport_w_scalings: &'a [ViewportWScalingNV],
21509     ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
21510         self.inner.viewport_count = viewport_w_scalings.len() as _;
21511         self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr();
21512         self
21513     }
21514     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21515     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21516     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportWScalingStateCreateInfoNV21517     pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV {
21518         self.inner
21519     }
21520 }
21521 #[repr(C)]
21522 #[derive(Copy, Clone, Default, Debug)]
21523 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewportSwizzleNV.html>"]
21524 pub struct ViewportSwizzleNV {
21525     pub x: ViewportCoordinateSwizzleNV,
21526     pub y: ViewportCoordinateSwizzleNV,
21527     pub z: ViewportCoordinateSwizzleNV,
21528     pub w: ViewportCoordinateSwizzleNV,
21529 }
21530 impl ViewportSwizzleNV {
builder<'a>() -> ViewportSwizzleNVBuilder<'a>21531     pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> {
21532         ViewportSwizzleNVBuilder {
21533             inner: ViewportSwizzleNV::default(),
21534             marker: ::std::marker::PhantomData,
21535         }
21536     }
21537 }
21538 #[repr(transparent)]
21539 pub struct ViewportSwizzleNVBuilder<'a> {
21540     inner: ViewportSwizzleNV,
21541     marker: ::std::marker::PhantomData<&'a ()>,
21542 }
21543 impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> {
21544     type Target = ViewportSwizzleNV;
deref(&self) -> &Self::Target21545     fn deref(&self) -> &Self::Target {
21546         &self.inner
21547     }
21548 }
21549 impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21550     fn deref_mut(&mut self) -> &mut Self::Target {
21551         &mut self.inner
21552     }
21553 }
21554 impl<'a> ViewportSwizzleNVBuilder<'a> {
x(mut self, x: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a>21555     pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
21556         self.inner.x = x;
21557         self
21558     }
y(mut self, y: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a>21559     pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
21560         self.inner.y = y;
21561         self
21562     }
z(mut self, z: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a>21563     pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
21564         self.inner.z = z;
21565         self
21566     }
w(mut self, w: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a>21567     pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
21568         self.inner.w = w;
21569         self
21570     }
21571     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21572     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21573     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ViewportSwizzleNV21574     pub fn build(self) -> ViewportSwizzleNV {
21575         self.inner
21576     }
21577 }
21578 #[repr(C)]
21579 #[derive(Copy, Clone, Debug)]
21580 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>"]
21581 pub struct PipelineViewportSwizzleStateCreateInfoNV {
21582     pub s_type: StructureType,
21583     pub p_next: *const c_void,
21584     pub flags: PipelineViewportSwizzleStateCreateFlagsNV,
21585     pub viewport_count: u32,
21586     pub p_viewport_swizzles: *const ViewportSwizzleNV,
21587 }
21588 impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV {
default() -> PipelineViewportSwizzleStateCreateInfoNV21589     fn default() -> PipelineViewportSwizzleStateCreateInfoNV {
21590         PipelineViewportSwizzleStateCreateInfoNV {
21591             s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
21592             p_next: ::std::ptr::null(),
21593             flags: PipelineViewportSwizzleStateCreateFlagsNV::default(),
21594             viewport_count: u32::default(),
21595             p_viewport_swizzles: ::std::ptr::null(),
21596         }
21597     }
21598 }
21599 impl PipelineViewportSwizzleStateCreateInfoNV {
builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a>21600     pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21601         PipelineViewportSwizzleStateCreateInfoNVBuilder {
21602             inner: PipelineViewportSwizzleStateCreateInfoNV::default(),
21603             marker: ::std::marker::PhantomData,
21604         }
21605     }
21606 }
21607 #[repr(transparent)]
21608 pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21609     inner: PipelineViewportSwizzleStateCreateInfoNV,
21610     marker: ::std::marker::PhantomData<&'a ()>,
21611 }
21612 unsafe impl ExtendsPipelineViewportStateCreateInfo
21613     for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_>
21614 {
21615 }
21616 unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {}
21617 impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21618     type Target = PipelineViewportSwizzleStateCreateInfoNV;
deref(&self) -> &Self::Target21619     fn deref(&self) -> &Self::Target {
21620         &self.inner
21621     }
21622 }
21623 impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21624     fn deref_mut(&mut self) -> &mut Self::Target {
21625         &mut self.inner
21626     }
21627 }
21628 impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
flags( mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV, ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a>21629     pub fn flags(
21630         mut self,
21631         flags: PipelineViewportSwizzleStateCreateFlagsNV,
21632     ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21633         self.inner.flags = flags;
21634         self
21635     }
viewport_swizzles( mut self, viewport_swizzles: &'a [ViewportSwizzleNV], ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a>21636     pub fn viewport_swizzles(
21637         mut self,
21638         viewport_swizzles: &'a [ViewportSwizzleNV],
21639     ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
21640         self.inner.viewport_count = viewport_swizzles.len() as _;
21641         self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr();
21642         self
21643     }
21644     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21645     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21646     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportSwizzleStateCreateInfoNV21647     pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV {
21648         self.inner
21649     }
21650 }
21651 #[repr(C)]
21652 #[derive(Copy, Clone, Debug)]
21653 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>"]
21654 pub struct PhysicalDeviceDiscardRectanglePropertiesEXT {
21655     pub s_type: StructureType,
21656     pub p_next: *mut c_void,
21657     pub max_discard_rectangles: u32,
21658 }
21659 impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT {
default() -> PhysicalDeviceDiscardRectanglePropertiesEXT21660     fn default() -> PhysicalDeviceDiscardRectanglePropertiesEXT {
21661         PhysicalDeviceDiscardRectanglePropertiesEXT {
21662             s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
21663             p_next: ::std::ptr::null_mut(),
21664             max_discard_rectangles: u32::default(),
21665         }
21666     }
21667 }
21668 impl PhysicalDeviceDiscardRectanglePropertiesEXT {
builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a>21669     pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
21670         PhysicalDeviceDiscardRectanglePropertiesEXTBuilder {
21671             inner: PhysicalDeviceDiscardRectanglePropertiesEXT::default(),
21672             marker: ::std::marker::PhantomData,
21673         }
21674     }
21675 }
21676 #[repr(transparent)]
21677 pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
21678     inner: PhysicalDeviceDiscardRectanglePropertiesEXT,
21679     marker: ::std::marker::PhantomData<&'a ()>,
21680 }
21681 unsafe impl ExtendsPhysicalDeviceProperties2
21682     for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_>
21683 {
21684 }
21685 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {}
21686 impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
21687     type Target = PhysicalDeviceDiscardRectanglePropertiesEXT;
deref(&self) -> &Self::Target21688     fn deref(&self) -> &Self::Target {
21689         &self.inner
21690     }
21691 }
21692 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21693     fn deref_mut(&mut self) -> &mut Self::Target {
21694         &mut self.inner
21695     }
21696 }
21697 impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
max_discard_rectangles( mut self, max_discard_rectangles: u32, ) -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a>21698     pub fn max_discard_rectangles(
21699         mut self,
21700         max_discard_rectangles: u32,
21701     ) -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
21702         self.inner.max_discard_rectangles = max_discard_rectangles;
21703         self
21704     }
21705     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21706     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21707     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT21708     pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT {
21709         self.inner
21710     }
21711 }
21712 #[repr(C)]
21713 #[derive(Copy, Clone, Debug)]
21714 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>"]
21715 pub struct PipelineDiscardRectangleStateCreateInfoEXT {
21716     pub s_type: StructureType,
21717     pub p_next: *const c_void,
21718     pub flags: PipelineDiscardRectangleStateCreateFlagsEXT,
21719     pub discard_rectangle_mode: DiscardRectangleModeEXT,
21720     pub discard_rectangle_count: u32,
21721     pub p_discard_rectangles: *const Rect2D,
21722 }
21723 impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT {
default() -> PipelineDiscardRectangleStateCreateInfoEXT21724     fn default() -> PipelineDiscardRectangleStateCreateInfoEXT {
21725         PipelineDiscardRectangleStateCreateInfoEXT {
21726             s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
21727             p_next: ::std::ptr::null(),
21728             flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(),
21729             discard_rectangle_mode: DiscardRectangleModeEXT::default(),
21730             discard_rectangle_count: u32::default(),
21731             p_discard_rectangles: ::std::ptr::null(),
21732         }
21733     }
21734 }
21735 impl PipelineDiscardRectangleStateCreateInfoEXT {
builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a>21736     pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
21737         PipelineDiscardRectangleStateCreateInfoEXTBuilder {
21738             inner: PipelineDiscardRectangleStateCreateInfoEXT::default(),
21739             marker: ::std::marker::PhantomData,
21740         }
21741     }
21742 }
21743 #[repr(transparent)]
21744 pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
21745     inner: PipelineDiscardRectangleStateCreateInfoEXT,
21746     marker: ::std::marker::PhantomData<&'a ()>,
21747 }
21748 unsafe impl ExtendsGraphicsPipelineCreateInfo
21749     for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_>
21750 {
21751 }
21752 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {}
21753 impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
21754     type Target = PipelineDiscardRectangleStateCreateInfoEXT;
deref(&self) -> &Self::Target21755     fn deref(&self) -> &Self::Target {
21756         &self.inner
21757     }
21758 }
21759 impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21760     fn deref_mut(&mut self) -> &mut Self::Target {
21761         &mut self.inner
21762     }
21763 }
21764 impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
flags( mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT, ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a>21765     pub fn flags(
21766         mut self,
21767         flags: PipelineDiscardRectangleStateCreateFlagsEXT,
21768     ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
21769         self.inner.flags = flags;
21770         self
21771     }
discard_rectangle_mode( mut self, discard_rectangle_mode: DiscardRectangleModeEXT, ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a>21772     pub fn discard_rectangle_mode(
21773         mut self,
21774         discard_rectangle_mode: DiscardRectangleModeEXT,
21775     ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
21776         self.inner.discard_rectangle_mode = discard_rectangle_mode;
21777         self
21778     }
discard_rectangles( mut self, discard_rectangles: &'a [Rect2D], ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a>21779     pub fn discard_rectangles(
21780         mut self,
21781         discard_rectangles: &'a [Rect2D],
21782     ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
21783         self.inner.discard_rectangle_count = discard_rectangles.len() as _;
21784         self.inner.p_discard_rectangles = discard_rectangles.as_ptr();
21785         self
21786     }
21787     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21788     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21789     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineDiscardRectangleStateCreateInfoEXT21790     pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT {
21791         self.inner
21792     }
21793 }
21794 #[repr(C)]
21795 #[derive(Copy, Clone, Debug)]
21796 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>"]
21797 pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
21798     pub s_type: StructureType,
21799     pub p_next: *mut c_void,
21800     pub per_view_position_all_components: Bool32,
21801 }
21802 impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
default() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX21803     fn default() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
21804         PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
21805             s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
21806             p_next: ::std::ptr::null_mut(),
21807             per_view_position_all_components: Bool32::default(),
21808         }
21809     }
21810 }
21811 impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a>21812     pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
21813         PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder {
21814             inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::default(),
21815             marker: ::std::marker::PhantomData,
21816         }
21817     }
21818 }
21819 #[repr(transparent)]
21820 pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
21821     inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
21822     marker: ::std::marker::PhantomData<&'a ()>,
21823 }
21824 unsafe impl ExtendsPhysicalDeviceProperties2
21825     for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_>
21826 {
21827 }
21828 unsafe impl ExtendsPhysicalDeviceProperties2
21829     for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
21830 {
21831 }
21832 impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
21833     type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
deref(&self) -> &Self::Target21834     fn deref(&self) -> &Self::Target {
21835         &self.inner
21836     }
21837 }
21838 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21839     fn deref_mut(&mut self) -> &mut Self::Target {
21840         &mut self.inner
21841     }
21842 }
21843 impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
per_view_position_all_components( mut self, per_view_position_all_components: bool, ) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a>21844     pub fn per_view_position_all_components(
21845         mut self,
21846         per_view_position_all_components: bool,
21847     ) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
21848         self.inner.per_view_position_all_components = per_view_position_all_components.into();
21849         self
21850     }
21851     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21852     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21853     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX21854     pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
21855         self.inner
21856     }
21857 }
21858 #[repr(C)]
21859 #[derive(Copy, Clone, Default, Debug)]
21860 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInputAttachmentAspectReference.html>"]
21861 pub struct InputAttachmentAspectReference {
21862     pub subpass: u32,
21863     pub input_attachment_index: u32,
21864     pub aspect_mask: ImageAspectFlags,
21865 }
21866 impl InputAttachmentAspectReference {
builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a>21867     pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> {
21868         InputAttachmentAspectReferenceBuilder {
21869             inner: InputAttachmentAspectReference::default(),
21870             marker: ::std::marker::PhantomData,
21871         }
21872     }
21873 }
21874 #[repr(transparent)]
21875 pub struct InputAttachmentAspectReferenceBuilder<'a> {
21876     inner: InputAttachmentAspectReference,
21877     marker: ::std::marker::PhantomData<&'a ()>,
21878 }
21879 impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> {
21880     type Target = InputAttachmentAspectReference;
deref(&self) -> &Self::Target21881     fn deref(&self) -> &Self::Target {
21882         &self.inner
21883     }
21884 }
21885 impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21886     fn deref_mut(&mut self) -> &mut Self::Target {
21887         &mut self.inner
21888     }
21889 }
21890 impl<'a> InputAttachmentAspectReferenceBuilder<'a> {
subpass(mut self, subpass: u32) -> InputAttachmentAspectReferenceBuilder<'a>21891     pub fn subpass(mut self, subpass: u32) -> InputAttachmentAspectReferenceBuilder<'a> {
21892         self.inner.subpass = subpass;
21893         self
21894     }
input_attachment_index( mut self, input_attachment_index: u32, ) -> InputAttachmentAspectReferenceBuilder<'a>21895     pub fn input_attachment_index(
21896         mut self,
21897         input_attachment_index: u32,
21898     ) -> InputAttachmentAspectReferenceBuilder<'a> {
21899         self.inner.input_attachment_index = input_attachment_index;
21900         self
21901     }
aspect_mask( mut self, aspect_mask: ImageAspectFlags, ) -> InputAttachmentAspectReferenceBuilder<'a>21902     pub fn aspect_mask(
21903         mut self,
21904         aspect_mask: ImageAspectFlags,
21905     ) -> InputAttachmentAspectReferenceBuilder<'a> {
21906         self.inner.aspect_mask = aspect_mask;
21907         self
21908     }
21909     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21910     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21911     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> InputAttachmentAspectReference21912     pub fn build(self) -> InputAttachmentAspectReference {
21913         self.inner
21914     }
21915 }
21916 #[repr(C)]
21917 #[derive(Copy, Clone, Debug)]
21918 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>"]
21919 pub struct RenderPassInputAttachmentAspectCreateInfo {
21920     pub s_type: StructureType,
21921     pub p_next: *const c_void,
21922     pub aspect_reference_count: u32,
21923     pub p_aspect_references: *const InputAttachmentAspectReference,
21924 }
21925 impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo {
default() -> RenderPassInputAttachmentAspectCreateInfo21926     fn default() -> RenderPassInputAttachmentAspectCreateInfo {
21927         RenderPassInputAttachmentAspectCreateInfo {
21928             s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
21929             p_next: ::std::ptr::null(),
21930             aspect_reference_count: u32::default(),
21931             p_aspect_references: ::std::ptr::null(),
21932         }
21933     }
21934 }
21935 impl RenderPassInputAttachmentAspectCreateInfo {
builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a>21936     pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
21937         RenderPassInputAttachmentAspectCreateInfoBuilder {
21938             inner: RenderPassInputAttachmentAspectCreateInfo::default(),
21939             marker: ::std::marker::PhantomData,
21940         }
21941     }
21942 }
21943 #[repr(transparent)]
21944 pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
21945     inner: RenderPassInputAttachmentAspectCreateInfo,
21946     marker: ::std::marker::PhantomData<&'a ()>,
21947 }
21948 unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {}
21949 unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {}
21950 impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
21951     type Target = RenderPassInputAttachmentAspectCreateInfo;
deref(&self) -> &Self::Target21952     fn deref(&self) -> &Self::Target {
21953         &self.inner
21954     }
21955 }
21956 impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target21957     fn deref_mut(&mut self) -> &mut Self::Target {
21958         &mut self.inner
21959     }
21960 }
21961 impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
aspect_references( mut self, aspect_references: &'a [InputAttachmentAspectReference], ) -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a>21962     pub fn aspect_references(
21963         mut self,
21964         aspect_references: &'a [InputAttachmentAspectReference],
21965     ) -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
21966         self.inner.aspect_reference_count = aspect_references.len() as _;
21967         self.inner.p_aspect_references = aspect_references.as_ptr();
21968         self
21969     }
21970     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
21971     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
21972     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassInputAttachmentAspectCreateInfo21973     pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo {
21974         self.inner
21975     }
21976 }
21977 #[repr(C)]
21978 #[derive(Copy, Clone, Debug)]
21979 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>"]
21980 pub struct PhysicalDeviceSurfaceInfo2KHR {
21981     pub s_type: StructureType,
21982     pub p_next: *const c_void,
21983     pub surface: SurfaceKHR,
21984 }
21985 impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR {
default() -> PhysicalDeviceSurfaceInfo2KHR21986     fn default() -> PhysicalDeviceSurfaceInfo2KHR {
21987         PhysicalDeviceSurfaceInfo2KHR {
21988             s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
21989             p_next: ::std::ptr::null(),
21990             surface: SurfaceKHR::default(),
21991         }
21992     }
21993 }
21994 impl PhysicalDeviceSurfaceInfo2KHR {
builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a>21995     pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
21996         PhysicalDeviceSurfaceInfo2KHRBuilder {
21997             inner: PhysicalDeviceSurfaceInfo2KHR::default(),
21998             marker: ::std::marker::PhantomData,
21999         }
22000     }
22001 }
22002 #[repr(transparent)]
22003 pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22004     inner: PhysicalDeviceSurfaceInfo2KHR,
22005     marker: ::std::marker::PhantomData<&'a ()>,
22006 }
22007 pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {}
22008 impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22009     type Target = PhysicalDeviceSurfaceInfo2KHR;
deref(&self) -> &Self::Target22010     fn deref(&self) -> &Self::Target {
22011         &self.inner
22012     }
22013 }
22014 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22015     fn deref_mut(&mut self) -> &mut Self::Target {
22016         &mut self.inner
22017     }
22018 }
22019 impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
surface(mut self, surface: SurfaceKHR) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a>22020     pub fn surface(mut self, surface: SurfaceKHR) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22021         self.inner.surface = surface;
22022         self
22023     }
22024     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22025     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22026     #[doc = r" valid extension structs can be pushed into the chain."]
22027     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22028     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>( mut self, next: &'a mut T, ) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a>22029     pub fn push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(
22030         mut self,
22031         next: &'a mut T,
22032     ) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
22033         unsafe {
22034             let next_ptr = next as *mut T as *mut BaseOutStructure;
22035             let last_next = ptr_chain_iter(next).last().unwrap();
22036             (*last_next).p_next = self.inner.p_next as _;
22037             self.inner.p_next = next_ptr as _;
22038         }
22039         self
22040     }
22041     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22042     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22043     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSurfaceInfo2KHR22044     pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR {
22045         self.inner
22046     }
22047 }
22048 #[repr(C)]
22049 #[derive(Copy, Clone, Debug)]
22050 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilities2KHR.html>"]
22051 pub struct SurfaceCapabilities2KHR {
22052     pub s_type: StructureType,
22053     pub p_next: *mut c_void,
22054     pub surface_capabilities: SurfaceCapabilitiesKHR,
22055 }
22056 impl ::std::default::Default for SurfaceCapabilities2KHR {
default() -> SurfaceCapabilities2KHR22057     fn default() -> SurfaceCapabilities2KHR {
22058         SurfaceCapabilities2KHR {
22059             s_type: StructureType::SURFACE_CAPABILITIES_2_KHR,
22060             p_next: ::std::ptr::null_mut(),
22061             surface_capabilities: SurfaceCapabilitiesKHR::default(),
22062         }
22063     }
22064 }
22065 impl SurfaceCapabilities2KHR {
builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a>22066     pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> {
22067         SurfaceCapabilities2KHRBuilder {
22068             inner: SurfaceCapabilities2KHR::default(),
22069             marker: ::std::marker::PhantomData,
22070         }
22071     }
22072 }
22073 #[repr(transparent)]
22074 pub struct SurfaceCapabilities2KHRBuilder<'a> {
22075     inner: SurfaceCapabilities2KHR,
22076     marker: ::std::marker::PhantomData<&'a ()>,
22077 }
22078 pub unsafe trait ExtendsSurfaceCapabilities2KHR {}
22079 impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> {
22080     type Target = SurfaceCapabilities2KHR;
deref(&self) -> &Self::Target22081     fn deref(&self) -> &Self::Target {
22082         &self.inner
22083     }
22084 }
22085 impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22086     fn deref_mut(&mut self) -> &mut Self::Target {
22087         &mut self.inner
22088     }
22089 }
22090 impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
surface_capabilities( mut self, surface_capabilities: SurfaceCapabilitiesKHR, ) -> SurfaceCapabilities2KHRBuilder<'a>22091     pub fn surface_capabilities(
22092         mut self,
22093         surface_capabilities: SurfaceCapabilitiesKHR,
22094     ) -> SurfaceCapabilities2KHRBuilder<'a> {
22095         self.inner.surface_capabilities = surface_capabilities;
22096         self
22097     }
22098     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22099     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22100     #[doc = r" valid extension structs can be pushed into the chain."]
22101     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22102     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSurfaceCapabilities2KHR>( mut self, next: &'a mut T, ) -> SurfaceCapabilities2KHRBuilder<'a>22103     pub fn push_next<T: ExtendsSurfaceCapabilities2KHR>(
22104         mut self,
22105         next: &'a mut T,
22106     ) -> SurfaceCapabilities2KHRBuilder<'a> {
22107         unsafe {
22108             let next_ptr = next as *mut T as *mut BaseOutStructure;
22109             let last_next = ptr_chain_iter(next).last().unwrap();
22110             (*last_next).p_next = self.inner.p_next as _;
22111             self.inner.p_next = next_ptr as _;
22112         }
22113         self
22114     }
22115     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22116     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22117     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilities2KHR22118     pub fn build(self) -> SurfaceCapabilities2KHR {
22119         self.inner
22120     }
22121 }
22122 #[repr(C)]
22123 #[derive(Copy, Clone, Debug)]
22124 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFormat2KHR.html>"]
22125 pub struct SurfaceFormat2KHR {
22126     pub s_type: StructureType,
22127     pub p_next: *mut c_void,
22128     pub surface_format: SurfaceFormatKHR,
22129 }
22130 impl ::std::default::Default for SurfaceFormat2KHR {
default() -> SurfaceFormat2KHR22131     fn default() -> SurfaceFormat2KHR {
22132         SurfaceFormat2KHR {
22133             s_type: StructureType::SURFACE_FORMAT_2_KHR,
22134             p_next: ::std::ptr::null_mut(),
22135             surface_format: SurfaceFormatKHR::default(),
22136         }
22137     }
22138 }
22139 impl SurfaceFormat2KHR {
builder<'a>() -> SurfaceFormat2KHRBuilder<'a>22140     pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> {
22141         SurfaceFormat2KHRBuilder {
22142             inner: SurfaceFormat2KHR::default(),
22143             marker: ::std::marker::PhantomData,
22144         }
22145     }
22146 }
22147 #[repr(transparent)]
22148 pub struct SurfaceFormat2KHRBuilder<'a> {
22149     inner: SurfaceFormat2KHR,
22150     marker: ::std::marker::PhantomData<&'a ()>,
22151 }
22152 pub unsafe trait ExtendsSurfaceFormat2KHR {}
22153 impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> {
22154     type Target = SurfaceFormat2KHR;
deref(&self) -> &Self::Target22155     fn deref(&self) -> &Self::Target {
22156         &self.inner
22157     }
22158 }
22159 impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22160     fn deref_mut(&mut self) -> &mut Self::Target {
22161         &mut self.inner
22162     }
22163 }
22164 impl<'a> SurfaceFormat2KHRBuilder<'a> {
surface_format( mut self, surface_format: SurfaceFormatKHR, ) -> SurfaceFormat2KHRBuilder<'a>22165     pub fn surface_format(
22166         mut self,
22167         surface_format: SurfaceFormatKHR,
22168     ) -> SurfaceFormat2KHRBuilder<'a> {
22169         self.inner.surface_format = surface_format;
22170         self
22171     }
22172     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22173     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22174     #[doc = r" valid extension structs can be pushed into the chain."]
22175     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22176     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSurfaceFormat2KHR>( mut self, next: &'a mut T, ) -> SurfaceFormat2KHRBuilder<'a>22177     pub fn push_next<T: ExtendsSurfaceFormat2KHR>(
22178         mut self,
22179         next: &'a mut T,
22180     ) -> SurfaceFormat2KHRBuilder<'a> {
22181         unsafe {
22182             let next_ptr = next as *mut T as *mut BaseOutStructure;
22183             let last_next = ptr_chain_iter(next).last().unwrap();
22184             (*last_next).p_next = self.inner.p_next as _;
22185             self.inner.p_next = next_ptr as _;
22186         }
22187         self
22188     }
22189     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22190     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22191     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFormat2KHR22192     pub fn build(self) -> SurfaceFormat2KHR {
22193         self.inner
22194     }
22195 }
22196 #[repr(C)]
22197 #[derive(Copy, Clone, Debug)]
22198 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayProperties2KHR.html>"]
22199 pub struct DisplayProperties2KHR {
22200     pub s_type: StructureType,
22201     pub p_next: *mut c_void,
22202     pub display_properties: DisplayPropertiesKHR,
22203 }
22204 impl ::std::default::Default for DisplayProperties2KHR {
default() -> DisplayProperties2KHR22205     fn default() -> DisplayProperties2KHR {
22206         DisplayProperties2KHR {
22207             s_type: StructureType::DISPLAY_PROPERTIES_2_KHR,
22208             p_next: ::std::ptr::null_mut(),
22209             display_properties: DisplayPropertiesKHR::default(),
22210         }
22211     }
22212 }
22213 impl DisplayProperties2KHR {
builder<'a>() -> DisplayProperties2KHRBuilder<'a>22214     pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> {
22215         DisplayProperties2KHRBuilder {
22216             inner: DisplayProperties2KHR::default(),
22217             marker: ::std::marker::PhantomData,
22218         }
22219     }
22220 }
22221 #[repr(transparent)]
22222 pub struct DisplayProperties2KHRBuilder<'a> {
22223     inner: DisplayProperties2KHR,
22224     marker: ::std::marker::PhantomData<&'a ()>,
22225 }
22226 pub unsafe trait ExtendsDisplayProperties2KHR {}
22227 impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> {
22228     type Target = DisplayProperties2KHR;
deref(&self) -> &Self::Target22229     fn deref(&self) -> &Self::Target {
22230         &self.inner
22231     }
22232 }
22233 impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22234     fn deref_mut(&mut self) -> &mut Self::Target {
22235         &mut self.inner
22236     }
22237 }
22238 impl<'a> DisplayProperties2KHRBuilder<'a> {
display_properties( mut self, display_properties: DisplayPropertiesKHR, ) -> DisplayProperties2KHRBuilder<'a>22239     pub fn display_properties(
22240         mut self,
22241         display_properties: DisplayPropertiesKHR,
22242     ) -> DisplayProperties2KHRBuilder<'a> {
22243         self.inner.display_properties = display_properties;
22244         self
22245     }
22246     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22247     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22248     #[doc = r" valid extension structs can be pushed into the chain."]
22249     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22250     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayProperties2KHR>( mut self, next: &'a mut T, ) -> DisplayProperties2KHRBuilder<'a>22251     pub fn push_next<T: ExtendsDisplayProperties2KHR>(
22252         mut self,
22253         next: &'a mut T,
22254     ) -> DisplayProperties2KHRBuilder<'a> {
22255         unsafe {
22256             let next_ptr = next as *mut T as *mut BaseOutStructure;
22257             let last_next = ptr_chain_iter(next).last().unwrap();
22258             (*last_next).p_next = self.inner.p_next as _;
22259             self.inner.p_next = next_ptr as _;
22260         }
22261         self
22262     }
22263     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22264     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22265     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayProperties2KHR22266     pub fn build(self) -> DisplayProperties2KHR {
22267         self.inner
22268     }
22269 }
22270 #[repr(C)]
22271 #[derive(Copy, Clone, Debug)]
22272 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneProperties2KHR.html>"]
22273 pub struct DisplayPlaneProperties2KHR {
22274     pub s_type: StructureType,
22275     pub p_next: *mut c_void,
22276     pub display_plane_properties: DisplayPlanePropertiesKHR,
22277 }
22278 impl ::std::default::Default for DisplayPlaneProperties2KHR {
default() -> DisplayPlaneProperties2KHR22279     fn default() -> DisplayPlaneProperties2KHR {
22280         DisplayPlaneProperties2KHR {
22281             s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR,
22282             p_next: ::std::ptr::null_mut(),
22283             display_plane_properties: DisplayPlanePropertiesKHR::default(),
22284         }
22285     }
22286 }
22287 impl DisplayPlaneProperties2KHR {
builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a>22288     pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> {
22289         DisplayPlaneProperties2KHRBuilder {
22290             inner: DisplayPlaneProperties2KHR::default(),
22291             marker: ::std::marker::PhantomData,
22292         }
22293     }
22294 }
22295 #[repr(transparent)]
22296 pub struct DisplayPlaneProperties2KHRBuilder<'a> {
22297     inner: DisplayPlaneProperties2KHR,
22298     marker: ::std::marker::PhantomData<&'a ()>,
22299 }
22300 pub unsafe trait ExtendsDisplayPlaneProperties2KHR {}
22301 impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> {
22302     type Target = DisplayPlaneProperties2KHR;
deref(&self) -> &Self::Target22303     fn deref(&self) -> &Self::Target {
22304         &self.inner
22305     }
22306 }
22307 impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22308     fn deref_mut(&mut self) -> &mut Self::Target {
22309         &mut self.inner
22310     }
22311 }
22312 impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
display_plane_properties( mut self, display_plane_properties: DisplayPlanePropertiesKHR, ) -> DisplayPlaneProperties2KHRBuilder<'a>22313     pub fn display_plane_properties(
22314         mut self,
22315         display_plane_properties: DisplayPlanePropertiesKHR,
22316     ) -> DisplayPlaneProperties2KHRBuilder<'a> {
22317         self.inner.display_plane_properties = display_plane_properties;
22318         self
22319     }
22320     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22321     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22322     #[doc = r" valid extension structs can be pushed into the chain."]
22323     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22324     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayPlaneProperties2KHR>( mut self, next: &'a mut T, ) -> DisplayPlaneProperties2KHRBuilder<'a>22325     pub fn push_next<T: ExtendsDisplayPlaneProperties2KHR>(
22326         mut self,
22327         next: &'a mut T,
22328     ) -> DisplayPlaneProperties2KHRBuilder<'a> {
22329         unsafe {
22330             let next_ptr = next as *mut T as *mut BaseOutStructure;
22331             let last_next = ptr_chain_iter(next).last().unwrap();
22332             (*last_next).p_next = self.inner.p_next as _;
22333             self.inner.p_next = next_ptr as _;
22334         }
22335         self
22336     }
22337     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22338     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22339     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneProperties2KHR22340     pub fn build(self) -> DisplayPlaneProperties2KHR {
22341         self.inner
22342     }
22343 }
22344 #[repr(C)]
22345 #[derive(Copy, Clone, Debug)]
22346 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeProperties2KHR.html>"]
22347 pub struct DisplayModeProperties2KHR {
22348     pub s_type: StructureType,
22349     pub p_next: *mut c_void,
22350     pub display_mode_properties: DisplayModePropertiesKHR,
22351 }
22352 impl ::std::default::Default for DisplayModeProperties2KHR {
default() -> DisplayModeProperties2KHR22353     fn default() -> DisplayModeProperties2KHR {
22354         DisplayModeProperties2KHR {
22355             s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR,
22356             p_next: ::std::ptr::null_mut(),
22357             display_mode_properties: DisplayModePropertiesKHR::default(),
22358         }
22359     }
22360 }
22361 impl DisplayModeProperties2KHR {
builder<'a>() -> DisplayModeProperties2KHRBuilder<'a>22362     pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> {
22363         DisplayModeProperties2KHRBuilder {
22364             inner: DisplayModeProperties2KHR::default(),
22365             marker: ::std::marker::PhantomData,
22366         }
22367     }
22368 }
22369 #[repr(transparent)]
22370 pub struct DisplayModeProperties2KHRBuilder<'a> {
22371     inner: DisplayModeProperties2KHR,
22372     marker: ::std::marker::PhantomData<&'a ()>,
22373 }
22374 pub unsafe trait ExtendsDisplayModeProperties2KHR {}
22375 impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> {
22376     type Target = DisplayModeProperties2KHR;
deref(&self) -> &Self::Target22377     fn deref(&self) -> &Self::Target {
22378         &self.inner
22379     }
22380 }
22381 impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22382     fn deref_mut(&mut self) -> &mut Self::Target {
22383         &mut self.inner
22384     }
22385 }
22386 impl<'a> DisplayModeProperties2KHRBuilder<'a> {
display_mode_properties( mut self, display_mode_properties: DisplayModePropertiesKHR, ) -> DisplayModeProperties2KHRBuilder<'a>22387     pub fn display_mode_properties(
22388         mut self,
22389         display_mode_properties: DisplayModePropertiesKHR,
22390     ) -> DisplayModeProperties2KHRBuilder<'a> {
22391         self.inner.display_mode_properties = display_mode_properties;
22392         self
22393     }
22394     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22395     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22396     #[doc = r" valid extension structs can be pushed into the chain."]
22397     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22398     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayModeProperties2KHR>( mut self, next: &'a mut T, ) -> DisplayModeProperties2KHRBuilder<'a>22399     pub fn push_next<T: ExtendsDisplayModeProperties2KHR>(
22400         mut self,
22401         next: &'a mut T,
22402     ) -> DisplayModeProperties2KHRBuilder<'a> {
22403         unsafe {
22404             let next_ptr = next as *mut T as *mut BaseOutStructure;
22405             let last_next = ptr_chain_iter(next).last().unwrap();
22406             (*last_next).p_next = self.inner.p_next as _;
22407             self.inner.p_next = next_ptr as _;
22408         }
22409         self
22410     }
22411     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22412     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22413     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayModeProperties2KHR22414     pub fn build(self) -> DisplayModeProperties2KHR {
22415         self.inner
22416     }
22417 }
22418 #[repr(C)]
22419 #[derive(Copy, Clone, Debug)]
22420 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneInfo2KHR.html>"]
22421 pub struct DisplayPlaneInfo2KHR {
22422     pub s_type: StructureType,
22423     pub p_next: *const c_void,
22424     pub mode: DisplayModeKHR,
22425     pub plane_index: u32,
22426 }
22427 impl ::std::default::Default for DisplayPlaneInfo2KHR {
default() -> DisplayPlaneInfo2KHR22428     fn default() -> DisplayPlaneInfo2KHR {
22429         DisplayPlaneInfo2KHR {
22430             s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR,
22431             p_next: ::std::ptr::null(),
22432             mode: DisplayModeKHR::default(),
22433             plane_index: u32::default(),
22434         }
22435     }
22436 }
22437 impl DisplayPlaneInfo2KHR {
builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a>22438     pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> {
22439         DisplayPlaneInfo2KHRBuilder {
22440             inner: DisplayPlaneInfo2KHR::default(),
22441             marker: ::std::marker::PhantomData,
22442         }
22443     }
22444 }
22445 #[repr(transparent)]
22446 pub struct DisplayPlaneInfo2KHRBuilder<'a> {
22447     inner: DisplayPlaneInfo2KHR,
22448     marker: ::std::marker::PhantomData<&'a ()>,
22449 }
22450 pub unsafe trait ExtendsDisplayPlaneInfo2KHR {}
22451 impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> {
22452     type Target = DisplayPlaneInfo2KHR;
deref(&self) -> &Self::Target22453     fn deref(&self) -> &Self::Target {
22454         &self.inner
22455     }
22456 }
22457 impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22458     fn deref_mut(&mut self) -> &mut Self::Target {
22459         &mut self.inner
22460     }
22461 }
22462 impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
mode(mut self, mode: DisplayModeKHR) -> DisplayPlaneInfo2KHRBuilder<'a>22463     pub fn mode(mut self, mode: DisplayModeKHR) -> DisplayPlaneInfo2KHRBuilder<'a> {
22464         self.inner.mode = mode;
22465         self
22466     }
plane_index(mut self, plane_index: u32) -> DisplayPlaneInfo2KHRBuilder<'a>22467     pub fn plane_index(mut self, plane_index: u32) -> DisplayPlaneInfo2KHRBuilder<'a> {
22468         self.inner.plane_index = plane_index;
22469         self
22470     }
22471     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22472     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22473     #[doc = r" valid extension structs can be pushed into the chain."]
22474     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22475     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayPlaneInfo2KHR>( mut self, next: &'a mut T, ) -> DisplayPlaneInfo2KHRBuilder<'a>22476     pub fn push_next<T: ExtendsDisplayPlaneInfo2KHR>(
22477         mut self,
22478         next: &'a mut T,
22479     ) -> DisplayPlaneInfo2KHRBuilder<'a> {
22480         unsafe {
22481             let next_ptr = next as *mut T as *mut BaseOutStructure;
22482             let last_next = ptr_chain_iter(next).last().unwrap();
22483             (*last_next).p_next = self.inner.p_next as _;
22484             self.inner.p_next = next_ptr as _;
22485         }
22486         self
22487     }
22488     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22489     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22490     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneInfo2KHR22491     pub fn build(self) -> DisplayPlaneInfo2KHR {
22492         self.inner
22493     }
22494 }
22495 #[repr(C)]
22496 #[derive(Copy, Clone, Debug)]
22497 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html>"]
22498 pub struct DisplayPlaneCapabilities2KHR {
22499     pub s_type: StructureType,
22500     pub p_next: *mut c_void,
22501     pub capabilities: DisplayPlaneCapabilitiesKHR,
22502 }
22503 impl ::std::default::Default for DisplayPlaneCapabilities2KHR {
default() -> DisplayPlaneCapabilities2KHR22504     fn default() -> DisplayPlaneCapabilities2KHR {
22505         DisplayPlaneCapabilities2KHR {
22506             s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR,
22507             p_next: ::std::ptr::null_mut(),
22508             capabilities: DisplayPlaneCapabilitiesKHR::default(),
22509         }
22510     }
22511 }
22512 impl DisplayPlaneCapabilities2KHR {
builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a>22513     pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> {
22514         DisplayPlaneCapabilities2KHRBuilder {
22515             inner: DisplayPlaneCapabilities2KHR::default(),
22516             marker: ::std::marker::PhantomData,
22517         }
22518     }
22519 }
22520 #[repr(transparent)]
22521 pub struct DisplayPlaneCapabilities2KHRBuilder<'a> {
22522     inner: DisplayPlaneCapabilities2KHR,
22523     marker: ::std::marker::PhantomData<&'a ()>,
22524 }
22525 pub unsafe trait ExtendsDisplayPlaneCapabilities2KHR {}
22526 impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> {
22527     type Target = DisplayPlaneCapabilities2KHR;
deref(&self) -> &Self::Target22528     fn deref(&self) -> &Self::Target {
22529         &self.inner
22530     }
22531 }
22532 impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22533     fn deref_mut(&mut self) -> &mut Self::Target {
22534         &mut self.inner
22535     }
22536 }
22537 impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
capabilities( mut self, capabilities: DisplayPlaneCapabilitiesKHR, ) -> DisplayPlaneCapabilities2KHRBuilder<'a>22538     pub fn capabilities(
22539         mut self,
22540         capabilities: DisplayPlaneCapabilitiesKHR,
22541     ) -> DisplayPlaneCapabilities2KHRBuilder<'a> {
22542         self.inner.capabilities = capabilities;
22543         self
22544     }
22545     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22546     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22547     #[doc = r" valid extension structs can be pushed into the chain."]
22548     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22549     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDisplayPlaneCapabilities2KHR>( mut self, next: &'a mut T, ) -> DisplayPlaneCapabilities2KHRBuilder<'a>22550     pub fn push_next<T: ExtendsDisplayPlaneCapabilities2KHR>(
22551         mut self,
22552         next: &'a mut T,
22553     ) -> DisplayPlaneCapabilities2KHRBuilder<'a> {
22554         unsafe {
22555             let next_ptr = next as *mut T as *mut BaseOutStructure;
22556             let last_next = ptr_chain_iter(next).last().unwrap();
22557             (*last_next).p_next = self.inner.p_next as _;
22558             self.inner.p_next = next_ptr as _;
22559         }
22560         self
22561     }
22562     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22563     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22564     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DisplayPlaneCapabilities2KHR22565     pub fn build(self) -> DisplayPlaneCapabilities2KHR {
22566         self.inner
22567     }
22568 }
22569 #[repr(C)]
22570 #[derive(Copy, Clone, Debug)]
22571 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>"]
22572 pub struct SharedPresentSurfaceCapabilitiesKHR {
22573     pub s_type: StructureType,
22574     pub p_next: *mut c_void,
22575     pub shared_present_supported_usage_flags: ImageUsageFlags,
22576 }
22577 impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR {
default() -> SharedPresentSurfaceCapabilitiesKHR22578     fn default() -> SharedPresentSurfaceCapabilitiesKHR {
22579         SharedPresentSurfaceCapabilitiesKHR {
22580             s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
22581             p_next: ::std::ptr::null_mut(),
22582             shared_present_supported_usage_flags: ImageUsageFlags::default(),
22583         }
22584     }
22585 }
22586 impl SharedPresentSurfaceCapabilitiesKHR {
builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a>22587     pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22588         SharedPresentSurfaceCapabilitiesKHRBuilder {
22589             inner: SharedPresentSurfaceCapabilitiesKHR::default(),
22590             marker: ::std::marker::PhantomData,
22591         }
22592     }
22593 }
22594 #[repr(transparent)]
22595 pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22596     inner: SharedPresentSurfaceCapabilitiesKHR,
22597     marker: ::std::marker::PhantomData<&'a ()>,
22598 }
22599 unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {}
22600 unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {}
22601 impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22602     type Target = SharedPresentSurfaceCapabilitiesKHR;
deref(&self) -> &Self::Target22603     fn deref(&self) -> &Self::Target {
22604         &self.inner
22605     }
22606 }
22607 impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22608     fn deref_mut(&mut self) -> &mut Self::Target {
22609         &mut self.inner
22610     }
22611 }
22612 impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
shared_present_supported_usage_flags( mut self, shared_present_supported_usage_flags: ImageUsageFlags, ) -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a>22613     pub fn shared_present_supported_usage_flags(
22614         mut self,
22615         shared_present_supported_usage_flags: ImageUsageFlags,
22616     ) -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
22617         self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags;
22618         self
22619     }
22620     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22621     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22622     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SharedPresentSurfaceCapabilitiesKHR22623     pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR {
22624         self.inner
22625     }
22626 }
22627 #[repr(C)]
22628 #[derive(Copy, Clone, Debug)]
22629 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html>"]
22630 pub struct PhysicalDevice16BitStorageFeatures {
22631     pub s_type: StructureType,
22632     pub p_next: *mut c_void,
22633     pub storage_buffer16_bit_access: Bool32,
22634     pub uniform_and_storage_buffer16_bit_access: Bool32,
22635     pub storage_push_constant16: Bool32,
22636     pub storage_input_output16: Bool32,
22637 }
22638 impl ::std::default::Default for PhysicalDevice16BitStorageFeatures {
default() -> PhysicalDevice16BitStorageFeatures22639     fn default() -> PhysicalDevice16BitStorageFeatures {
22640         PhysicalDevice16BitStorageFeatures {
22641             s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
22642             p_next: ::std::ptr::null_mut(),
22643             storage_buffer16_bit_access: Bool32::default(),
22644             uniform_and_storage_buffer16_bit_access: Bool32::default(),
22645             storage_push_constant16: Bool32::default(),
22646             storage_input_output16: Bool32::default(),
22647         }
22648     }
22649 }
22650 impl PhysicalDevice16BitStorageFeatures {
builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a>22651     pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22652         PhysicalDevice16BitStorageFeaturesBuilder {
22653             inner: PhysicalDevice16BitStorageFeatures::default(),
22654             marker: ::std::marker::PhantomData,
22655         }
22656     }
22657 }
22658 #[repr(transparent)]
22659 pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22660     inner: PhysicalDevice16BitStorageFeatures,
22661     marker: ::std::marker::PhantomData<&'a ()>,
22662 }
22663 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
22664 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {}
22665 impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22666     type Target = PhysicalDevice16BitStorageFeatures;
deref(&self) -> &Self::Target22667     fn deref(&self) -> &Self::Target {
22668         &self.inner
22669     }
22670 }
22671 impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22672     fn deref_mut(&mut self) -> &mut Self::Target {
22673         &mut self.inner
22674     }
22675 }
22676 impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
storage_buffer16_bit_access( mut self, storage_buffer16_bit_access: bool, ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a>22677     pub fn storage_buffer16_bit_access(
22678         mut self,
22679         storage_buffer16_bit_access: bool,
22680     ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22681         self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
22682         self
22683     }
uniform_and_storage_buffer16_bit_access( mut self, uniform_and_storage_buffer16_bit_access: bool, ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a>22684     pub fn uniform_and_storage_buffer16_bit_access(
22685         mut self,
22686         uniform_and_storage_buffer16_bit_access: bool,
22687     ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22688         self.inner.uniform_and_storage_buffer16_bit_access =
22689             uniform_and_storage_buffer16_bit_access.into();
22690         self
22691     }
storage_push_constant16( mut self, storage_push_constant16: bool, ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a>22692     pub fn storage_push_constant16(
22693         mut self,
22694         storage_push_constant16: bool,
22695     ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22696         self.inner.storage_push_constant16 = storage_push_constant16.into();
22697         self
22698     }
storage_input_output16( mut self, storage_input_output16: bool, ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a>22699     pub fn storage_input_output16(
22700         mut self,
22701         storage_input_output16: bool,
22702     ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
22703         self.inner.storage_input_output16 = storage_input_output16.into();
22704         self
22705     }
22706     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22707     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22708     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevice16BitStorageFeatures22709     pub fn build(self) -> PhysicalDevice16BitStorageFeatures {
22710         self.inner
22711     }
22712 }
22713 #[repr(C)]
22714 #[derive(Copy, Clone, Debug)]
22715 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html>"]
22716 pub struct PhysicalDeviceSubgroupProperties {
22717     pub s_type: StructureType,
22718     pub p_next: *mut c_void,
22719     pub subgroup_size: u32,
22720     pub supported_stages: ShaderStageFlags,
22721     pub supported_operations: SubgroupFeatureFlags,
22722     pub quad_operations_in_all_stages: Bool32,
22723 }
22724 impl ::std::default::Default for PhysicalDeviceSubgroupProperties {
default() -> PhysicalDeviceSubgroupProperties22725     fn default() -> PhysicalDeviceSubgroupProperties {
22726         PhysicalDeviceSubgroupProperties {
22727             s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
22728             p_next: ::std::ptr::null_mut(),
22729             subgroup_size: u32::default(),
22730             supported_stages: ShaderStageFlags::default(),
22731             supported_operations: SubgroupFeatureFlags::default(),
22732             quad_operations_in_all_stages: Bool32::default(),
22733         }
22734     }
22735 }
22736 impl PhysicalDeviceSubgroupProperties {
builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a>22737     pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
22738         PhysicalDeviceSubgroupPropertiesBuilder {
22739             inner: PhysicalDeviceSubgroupProperties::default(),
22740             marker: ::std::marker::PhantomData,
22741         }
22742     }
22743 }
22744 #[repr(transparent)]
22745 pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> {
22746     inner: PhysicalDeviceSubgroupProperties,
22747     marker: ::std::marker::PhantomData<&'a ()>,
22748 }
22749 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {}
22750 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {}
22751 impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
22752     type Target = PhysicalDeviceSubgroupProperties;
deref(&self) -> &Self::Target22753     fn deref(&self) -> &Self::Target {
22754         &self.inner
22755     }
22756 }
22757 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22758     fn deref_mut(&mut self) -> &mut Self::Target {
22759         &mut self.inner
22760     }
22761 }
22762 impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
subgroup_size( mut self, subgroup_size: u32, ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a>22763     pub fn subgroup_size(
22764         mut self,
22765         subgroup_size: u32,
22766     ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
22767         self.inner.subgroup_size = subgroup_size;
22768         self
22769     }
supported_stages( mut self, supported_stages: ShaderStageFlags, ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a>22770     pub fn supported_stages(
22771         mut self,
22772         supported_stages: ShaderStageFlags,
22773     ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
22774         self.inner.supported_stages = supported_stages;
22775         self
22776     }
supported_operations( mut self, supported_operations: SubgroupFeatureFlags, ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a>22777     pub fn supported_operations(
22778         mut self,
22779         supported_operations: SubgroupFeatureFlags,
22780     ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
22781         self.inner.supported_operations = supported_operations;
22782         self
22783     }
quad_operations_in_all_stages( mut self, quad_operations_in_all_stages: bool, ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a>22784     pub fn quad_operations_in_all_stages(
22785         mut self,
22786         quad_operations_in_all_stages: bool,
22787     ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
22788         self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into();
22789         self
22790     }
22791     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22792     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22793     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubgroupProperties22794     pub fn build(self) -> PhysicalDeviceSubgroupProperties {
22795         self.inner
22796     }
22797 }
22798 #[repr(C)]
22799 #[derive(Copy, Clone, Debug)]
22800 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>"]
22801 pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
22802     pub s_type: StructureType,
22803     pub p_next: *mut c_void,
22804     pub shader_subgroup_extended_types: Bool32,
22805 }
22806 impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
default() -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures22807     fn default() -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
22808         PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
22809             s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
22810             p_next: ::std::ptr::null_mut(),
22811             shader_subgroup_extended_types: Bool32::default(),
22812         }
22813     }
22814 }
22815 impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a>22816     pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
22817         PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder {
22818             inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures::default(),
22819             marker: ::std::marker::PhantomData,
22820         }
22821     }
22822 }
22823 #[repr(transparent)]
22824 pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
22825     inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
22826     marker: ::std::marker::PhantomData<&'a ()>,
22827 }
22828 unsafe impl ExtendsDeviceCreateInfo
22829     for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
22830 {
22831 }
22832 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
22833 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
22834     type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
deref(&self) -> &Self::Target22835     fn deref(&self) -> &Self::Target {
22836         &self.inner
22837     }
22838 }
22839 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target22840     fn deref_mut(&mut self) -> &mut Self::Target {
22841         &mut self.inner
22842     }
22843 }
22844 impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
shader_subgroup_extended_types( mut self, shader_subgroup_extended_types: bool, ) -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a>22845     pub fn shader_subgroup_extended_types(
22846         mut self,
22847         shader_subgroup_extended_types: bool,
22848     ) -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
22849         self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
22850         self
22851     }
22852     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22853     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22854     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures22855     pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
22856         self.inner
22857     }
22858 }
22859 #[repr(C)]
22860 #[derive(Copy, Clone, Debug)]
22861 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferMemoryRequirementsInfo2.html>"]
22862 pub struct BufferMemoryRequirementsInfo2 {
22863     pub s_type: StructureType,
22864     pub p_next: *const c_void,
22865     pub buffer: Buffer,
22866 }
22867 impl ::std::default::Default for BufferMemoryRequirementsInfo2 {
default() -> BufferMemoryRequirementsInfo222868     fn default() -> BufferMemoryRequirementsInfo2 {
22869         BufferMemoryRequirementsInfo2 {
22870             s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2,
22871             p_next: ::std::ptr::null(),
22872             buffer: Buffer::default(),
22873         }
22874     }
22875 }
22876 impl BufferMemoryRequirementsInfo2 {
builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a>22877     pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> {
22878         BufferMemoryRequirementsInfo2Builder {
22879             inner: BufferMemoryRequirementsInfo2::default(),
22880             marker: ::std::marker::PhantomData,
22881         }
22882     }
22883 }
22884 #[repr(transparent)]
22885 pub struct BufferMemoryRequirementsInfo2Builder<'a> {
22886     inner: BufferMemoryRequirementsInfo2,
22887     marker: ::std::marker::PhantomData<&'a ()>,
22888 }
22889 pub unsafe trait ExtendsBufferMemoryRequirementsInfo2 {}
22890 impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> {
22891     type Target = BufferMemoryRequirementsInfo2;
deref(&self) -> &Self::Target22892     fn deref(&self) -> &Self::Target {
22893         &self.inner
22894     }
22895 }
22896 impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target22897     fn deref_mut(&mut self) -> &mut Self::Target {
22898         &mut self.inner
22899     }
22900 }
22901 impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
buffer(mut self, buffer: Buffer) -> BufferMemoryRequirementsInfo2Builder<'a>22902     pub fn buffer(mut self, buffer: Buffer) -> BufferMemoryRequirementsInfo2Builder<'a> {
22903         self.inner.buffer = buffer;
22904         self
22905     }
22906     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22907     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22908     #[doc = r" valid extension structs can be pushed into the chain."]
22909     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22910     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferMemoryRequirementsInfo2>( mut self, next: &'a mut T, ) -> BufferMemoryRequirementsInfo2Builder<'a>22911     pub fn push_next<T: ExtendsBufferMemoryRequirementsInfo2>(
22912         mut self,
22913         next: &'a mut T,
22914     ) -> BufferMemoryRequirementsInfo2Builder<'a> {
22915         unsafe {
22916             let next_ptr = next as *mut T as *mut BaseOutStructure;
22917             let last_next = ptr_chain_iter(next).last().unwrap();
22918             (*last_next).p_next = self.inner.p_next as _;
22919             self.inner.p_next = next_ptr as _;
22920         }
22921         self
22922     }
22923     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22924     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22925     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferMemoryRequirementsInfo222926     pub fn build(self) -> BufferMemoryRequirementsInfo2 {
22927         self.inner
22928     }
22929 }
22930 #[repr(C)]
22931 #[derive(Copy, Clone, Debug)]
22932 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageMemoryRequirementsInfo2.html>"]
22933 pub struct ImageMemoryRequirementsInfo2 {
22934     pub s_type: StructureType,
22935     pub p_next: *const c_void,
22936     pub image: Image,
22937 }
22938 impl ::std::default::Default for ImageMemoryRequirementsInfo2 {
default() -> ImageMemoryRequirementsInfo222939     fn default() -> ImageMemoryRequirementsInfo2 {
22940         ImageMemoryRequirementsInfo2 {
22941             s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2,
22942             p_next: ::std::ptr::null(),
22943             image: Image::default(),
22944         }
22945     }
22946 }
22947 impl ImageMemoryRequirementsInfo2 {
builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a>22948     pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> {
22949         ImageMemoryRequirementsInfo2Builder {
22950             inner: ImageMemoryRequirementsInfo2::default(),
22951             marker: ::std::marker::PhantomData,
22952         }
22953     }
22954 }
22955 #[repr(transparent)]
22956 pub struct ImageMemoryRequirementsInfo2Builder<'a> {
22957     inner: ImageMemoryRequirementsInfo2,
22958     marker: ::std::marker::PhantomData<&'a ()>,
22959 }
22960 pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {}
22961 impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> {
22962     type Target = ImageMemoryRequirementsInfo2;
deref(&self) -> &Self::Target22963     fn deref(&self) -> &Self::Target {
22964         &self.inner
22965     }
22966 }
22967 impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target22968     fn deref_mut(&mut self) -> &mut Self::Target {
22969         &mut self.inner
22970     }
22971 }
22972 impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
image(mut self, image: Image) -> ImageMemoryRequirementsInfo2Builder<'a>22973     pub fn image(mut self, image: Image) -> ImageMemoryRequirementsInfo2Builder<'a> {
22974         self.inner.image = image;
22975         self
22976     }
22977     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
22978     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
22979     #[doc = r" valid extension structs can be pushed into the chain."]
22980     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
22981     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageMemoryRequirementsInfo2>( mut self, next: &'a mut T, ) -> ImageMemoryRequirementsInfo2Builder<'a>22982     pub fn push_next<T: ExtendsImageMemoryRequirementsInfo2>(
22983         mut self,
22984         next: &'a mut T,
22985     ) -> ImageMemoryRequirementsInfo2Builder<'a> {
22986         unsafe {
22987             let next_ptr = next as *mut T as *mut BaseOutStructure;
22988             let last_next = ptr_chain_iter(next).last().unwrap();
22989             (*last_next).p_next = self.inner.p_next as _;
22990             self.inner.p_next = next_ptr as _;
22991         }
22992         self
22993     }
22994     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
22995     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
22996     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageMemoryRequirementsInfo222997     pub fn build(self) -> ImageMemoryRequirementsInfo2 {
22998         self.inner
22999     }
23000 }
23001 #[repr(C)]
23002 #[derive(Copy, Clone, Debug)]
23003 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html>"]
23004 pub struct ImageSparseMemoryRequirementsInfo2 {
23005     pub s_type: StructureType,
23006     pub p_next: *const c_void,
23007     pub image: Image,
23008 }
23009 impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 {
default() -> ImageSparseMemoryRequirementsInfo223010     fn default() -> ImageSparseMemoryRequirementsInfo2 {
23011         ImageSparseMemoryRequirementsInfo2 {
23012             s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
23013             p_next: ::std::ptr::null(),
23014             image: Image::default(),
23015         }
23016     }
23017 }
23018 impl ImageSparseMemoryRequirementsInfo2 {
builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a>23019     pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
23020         ImageSparseMemoryRequirementsInfo2Builder {
23021             inner: ImageSparseMemoryRequirementsInfo2::default(),
23022             marker: ::std::marker::PhantomData,
23023         }
23024     }
23025 }
23026 #[repr(transparent)]
23027 pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> {
23028     inner: ImageSparseMemoryRequirementsInfo2,
23029     marker: ::std::marker::PhantomData<&'a ()>,
23030 }
23031 pub unsafe trait ExtendsImageSparseMemoryRequirementsInfo2 {}
23032 impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> {
23033     type Target = ImageSparseMemoryRequirementsInfo2;
deref(&self) -> &Self::Target23034     fn deref(&self) -> &Self::Target {
23035         &self.inner
23036     }
23037 }
23038 impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23039     fn deref_mut(&mut self) -> &mut Self::Target {
23040         &mut self.inner
23041     }
23042 }
23043 impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
image(mut self, image: Image) -> ImageSparseMemoryRequirementsInfo2Builder<'a>23044     pub fn image(mut self, image: Image) -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
23045         self.inner.image = image;
23046         self
23047     }
23048     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
23049     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
23050     #[doc = r" valid extension structs can be pushed into the chain."]
23051     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
23052     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageSparseMemoryRequirementsInfo2>( mut self, next: &'a mut T, ) -> ImageSparseMemoryRequirementsInfo2Builder<'a>23053     pub fn push_next<T: ExtendsImageSparseMemoryRequirementsInfo2>(
23054         mut self,
23055         next: &'a mut T,
23056     ) -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
23057         unsafe {
23058             let next_ptr = next as *mut T as *mut BaseOutStructure;
23059             let last_next = ptr_chain_iter(next).last().unwrap();
23060             (*last_next).p_next = self.inner.p_next as _;
23061             self.inner.p_next = next_ptr as _;
23062         }
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."]
build(self) -> ImageSparseMemoryRequirementsInfo223068     pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 {
23069         self.inner
23070     }
23071 }
23072 #[repr(C)]
23073 #[derive(Copy, Clone, Debug)]
23074 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryRequirements2.html>"]
23075 pub struct MemoryRequirements2 {
23076     pub s_type: StructureType,
23077     pub p_next: *mut c_void,
23078     pub memory_requirements: MemoryRequirements,
23079 }
23080 impl ::std::default::Default for MemoryRequirements2 {
default() -> MemoryRequirements223081     fn default() -> MemoryRequirements2 {
23082         MemoryRequirements2 {
23083             s_type: StructureType::MEMORY_REQUIREMENTS_2,
23084             p_next: ::std::ptr::null_mut(),
23085             memory_requirements: MemoryRequirements::default(),
23086         }
23087     }
23088 }
23089 impl MemoryRequirements2 {
builder<'a>() -> MemoryRequirements2Builder<'a>23090     pub fn builder<'a>() -> MemoryRequirements2Builder<'a> {
23091         MemoryRequirements2Builder {
23092             inner: MemoryRequirements2::default(),
23093             marker: ::std::marker::PhantomData,
23094         }
23095     }
23096 }
23097 #[repr(transparent)]
23098 pub struct MemoryRequirements2Builder<'a> {
23099     inner: MemoryRequirements2,
23100     marker: ::std::marker::PhantomData<&'a ()>,
23101 }
23102 pub unsafe trait ExtendsMemoryRequirements2 {}
23103 impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> {
23104     type Target = MemoryRequirements2;
deref(&self) -> &Self::Target23105     fn deref(&self) -> &Self::Target {
23106         &self.inner
23107     }
23108 }
23109 impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23110     fn deref_mut(&mut self) -> &mut Self::Target {
23111         &mut self.inner
23112     }
23113 }
23114 impl<'a> MemoryRequirements2Builder<'a> {
memory_requirements( mut self, memory_requirements: MemoryRequirements, ) -> MemoryRequirements2Builder<'a>23115     pub fn memory_requirements(
23116         mut self,
23117         memory_requirements: MemoryRequirements,
23118     ) -> MemoryRequirements2Builder<'a> {
23119         self.inner.memory_requirements = memory_requirements;
23120         self
23121     }
23122     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
23123     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
23124     #[doc = r" valid extension structs can be pushed into the chain."]
23125     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
23126     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryRequirements2>( mut self, next: &'a mut T, ) -> MemoryRequirements2Builder<'a>23127     pub fn push_next<T: ExtendsMemoryRequirements2>(
23128         mut self,
23129         next: &'a mut T,
23130     ) -> MemoryRequirements2Builder<'a> {
23131         unsafe {
23132             let next_ptr = next as *mut T as *mut BaseOutStructure;
23133             let last_next = ptr_chain_iter(next).last().unwrap();
23134             (*last_next).p_next = self.inner.p_next as _;
23135             self.inner.p_next = next_ptr as _;
23136         }
23137         self
23138     }
23139     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23140     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23141     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryRequirements223142     pub fn build(self) -> MemoryRequirements2 {
23143         self.inner
23144     }
23145 }
23146 #[repr(C)]
23147 #[derive(Copy, Clone, Debug)]
23148 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryRequirements2.html>"]
23149 pub struct SparseImageMemoryRequirements2 {
23150     pub s_type: StructureType,
23151     pub p_next: *mut c_void,
23152     pub memory_requirements: SparseImageMemoryRequirements,
23153 }
23154 impl ::std::default::Default for SparseImageMemoryRequirements2 {
default() -> SparseImageMemoryRequirements223155     fn default() -> SparseImageMemoryRequirements2 {
23156         SparseImageMemoryRequirements2 {
23157             s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
23158             p_next: ::std::ptr::null_mut(),
23159             memory_requirements: SparseImageMemoryRequirements::default(),
23160         }
23161     }
23162 }
23163 impl SparseImageMemoryRequirements2 {
builder<'a>() -> SparseImageMemoryRequirements2Builder<'a>23164     pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> {
23165         SparseImageMemoryRequirements2Builder {
23166             inner: SparseImageMemoryRequirements2::default(),
23167             marker: ::std::marker::PhantomData,
23168         }
23169     }
23170 }
23171 #[repr(transparent)]
23172 pub struct SparseImageMemoryRequirements2Builder<'a> {
23173     inner: SparseImageMemoryRequirements2,
23174     marker: ::std::marker::PhantomData<&'a ()>,
23175 }
23176 pub unsafe trait ExtendsSparseImageMemoryRequirements2 {}
23177 impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> {
23178     type Target = SparseImageMemoryRequirements2;
deref(&self) -> &Self::Target23179     fn deref(&self) -> &Self::Target {
23180         &self.inner
23181     }
23182 }
23183 impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target23184     fn deref_mut(&mut self) -> &mut Self::Target {
23185         &mut self.inner
23186     }
23187 }
23188 impl<'a> SparseImageMemoryRequirements2Builder<'a> {
memory_requirements( mut self, memory_requirements: SparseImageMemoryRequirements, ) -> SparseImageMemoryRequirements2Builder<'a>23189     pub fn memory_requirements(
23190         mut self,
23191         memory_requirements: SparseImageMemoryRequirements,
23192     ) -> SparseImageMemoryRequirements2Builder<'a> {
23193         self.inner.memory_requirements = memory_requirements;
23194         self
23195     }
23196     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
23197     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
23198     #[doc = r" valid extension structs can be pushed into the chain."]
23199     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
23200     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSparseImageMemoryRequirements2>( mut self, next: &'a mut T, ) -> SparseImageMemoryRequirements2Builder<'a>23201     pub fn push_next<T: ExtendsSparseImageMemoryRequirements2>(
23202         mut self,
23203         next: &'a mut T,
23204     ) -> SparseImageMemoryRequirements2Builder<'a> {
23205         unsafe {
23206             let next_ptr = next as *mut T as *mut BaseOutStructure;
23207             let last_next = ptr_chain_iter(next).last().unwrap();
23208             (*last_next).p_next = self.inner.p_next as _;
23209             self.inner.p_next = next_ptr as _;
23210         }
23211         self
23212     }
23213     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23214     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23215     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SparseImageMemoryRequirements223216     pub fn build(self) -> SparseImageMemoryRequirements2 {
23217         self.inner
23218     }
23219 }
23220 #[repr(C)]
23221 #[derive(Copy, Clone, Debug)]
23222 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePointClippingProperties.html>"]
23223 pub struct PhysicalDevicePointClippingProperties {
23224     pub s_type: StructureType,
23225     pub p_next: *mut c_void,
23226     pub point_clipping_behavior: PointClippingBehavior,
23227 }
23228 impl ::std::default::Default for PhysicalDevicePointClippingProperties {
default() -> PhysicalDevicePointClippingProperties23229     fn default() -> PhysicalDevicePointClippingProperties {
23230         PhysicalDevicePointClippingProperties {
23231             s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
23232             p_next: ::std::ptr::null_mut(),
23233             point_clipping_behavior: PointClippingBehavior::default(),
23234         }
23235     }
23236 }
23237 impl PhysicalDevicePointClippingProperties {
builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a>23238     pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
23239         PhysicalDevicePointClippingPropertiesBuilder {
23240             inner: PhysicalDevicePointClippingProperties::default(),
23241             marker: ::std::marker::PhantomData,
23242         }
23243     }
23244 }
23245 #[repr(transparent)]
23246 pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> {
23247     inner: PhysicalDevicePointClippingProperties,
23248     marker: ::std::marker::PhantomData<&'a ()>,
23249 }
23250 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {}
23251 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {}
23252 impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> {
23253     type Target = PhysicalDevicePointClippingProperties;
deref(&self) -> &Self::Target23254     fn deref(&self) -> &Self::Target {
23255         &self.inner
23256     }
23257 }
23258 impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23259     fn deref_mut(&mut self) -> &mut Self::Target {
23260         &mut self.inner
23261     }
23262 }
23263 impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
point_clipping_behavior( mut self, point_clipping_behavior: PointClippingBehavior, ) -> PhysicalDevicePointClippingPropertiesBuilder<'a>23264     pub fn point_clipping_behavior(
23265         mut self,
23266         point_clipping_behavior: PointClippingBehavior,
23267     ) -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
23268         self.inner.point_clipping_behavior = point_clipping_behavior;
23269         self
23270     }
23271     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23272     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23273     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePointClippingProperties23274     pub fn build(self) -> PhysicalDevicePointClippingProperties {
23275         self.inner
23276     }
23277 }
23278 #[repr(C)]
23279 #[derive(Copy, Clone, Debug)]
23280 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryDedicatedRequirements.html>"]
23281 pub struct MemoryDedicatedRequirements {
23282     pub s_type: StructureType,
23283     pub p_next: *mut c_void,
23284     pub prefers_dedicated_allocation: Bool32,
23285     pub requires_dedicated_allocation: Bool32,
23286 }
23287 impl ::std::default::Default for MemoryDedicatedRequirements {
default() -> MemoryDedicatedRequirements23288     fn default() -> MemoryDedicatedRequirements {
23289         MemoryDedicatedRequirements {
23290             s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS,
23291             p_next: ::std::ptr::null_mut(),
23292             prefers_dedicated_allocation: Bool32::default(),
23293             requires_dedicated_allocation: Bool32::default(),
23294         }
23295     }
23296 }
23297 impl MemoryDedicatedRequirements {
builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a>23298     pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> {
23299         MemoryDedicatedRequirementsBuilder {
23300             inner: MemoryDedicatedRequirements::default(),
23301             marker: ::std::marker::PhantomData,
23302         }
23303     }
23304 }
23305 #[repr(transparent)]
23306 pub struct MemoryDedicatedRequirementsBuilder<'a> {
23307     inner: MemoryDedicatedRequirements,
23308     marker: ::std::marker::PhantomData<&'a ()>,
23309 }
23310 unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {}
23311 unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {}
23312 impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> {
23313     type Target = MemoryDedicatedRequirements;
deref(&self) -> &Self::Target23314     fn deref(&self) -> &Self::Target {
23315         &self.inner
23316     }
23317 }
23318 impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23319     fn deref_mut(&mut self) -> &mut Self::Target {
23320         &mut self.inner
23321     }
23322 }
23323 impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
prefers_dedicated_allocation( mut self, prefers_dedicated_allocation: bool, ) -> MemoryDedicatedRequirementsBuilder<'a>23324     pub fn prefers_dedicated_allocation(
23325         mut self,
23326         prefers_dedicated_allocation: bool,
23327     ) -> MemoryDedicatedRequirementsBuilder<'a> {
23328         self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into();
23329         self
23330     }
requires_dedicated_allocation( mut self, requires_dedicated_allocation: bool, ) -> MemoryDedicatedRequirementsBuilder<'a>23331     pub fn requires_dedicated_allocation(
23332         mut self,
23333         requires_dedicated_allocation: bool,
23334     ) -> MemoryDedicatedRequirementsBuilder<'a> {
23335         self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into();
23336         self
23337     }
23338     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23339     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23340     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryDedicatedRequirements23341     pub fn build(self) -> MemoryDedicatedRequirements {
23342         self.inner
23343     }
23344 }
23345 #[repr(C)]
23346 #[derive(Copy, Clone, Debug)]
23347 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryDedicatedAllocateInfo.html>"]
23348 pub struct MemoryDedicatedAllocateInfo {
23349     pub s_type: StructureType,
23350     pub p_next: *const c_void,
23351     pub image: Image,
23352     pub buffer: Buffer,
23353 }
23354 impl ::std::default::Default for MemoryDedicatedAllocateInfo {
default() -> MemoryDedicatedAllocateInfo23355     fn default() -> MemoryDedicatedAllocateInfo {
23356         MemoryDedicatedAllocateInfo {
23357             s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO,
23358             p_next: ::std::ptr::null(),
23359             image: Image::default(),
23360             buffer: Buffer::default(),
23361         }
23362     }
23363 }
23364 impl MemoryDedicatedAllocateInfo {
builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a>23365     pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> {
23366         MemoryDedicatedAllocateInfoBuilder {
23367             inner: MemoryDedicatedAllocateInfo::default(),
23368             marker: ::std::marker::PhantomData,
23369         }
23370     }
23371 }
23372 #[repr(transparent)]
23373 pub struct MemoryDedicatedAllocateInfoBuilder<'a> {
23374     inner: MemoryDedicatedAllocateInfo,
23375     marker: ::std::marker::PhantomData<&'a ()>,
23376 }
23377 unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {}
23378 unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {}
23379 impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> {
23380     type Target = MemoryDedicatedAllocateInfo;
deref(&self) -> &Self::Target23381     fn deref(&self) -> &Self::Target {
23382         &self.inner
23383     }
23384 }
23385 impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23386     fn deref_mut(&mut self) -> &mut Self::Target {
23387         &mut self.inner
23388     }
23389 }
23390 impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
image(mut self, image: Image) -> MemoryDedicatedAllocateInfoBuilder<'a>23391     pub fn image(mut self, image: Image) -> MemoryDedicatedAllocateInfoBuilder<'a> {
23392         self.inner.image = image;
23393         self
23394     }
buffer(mut self, buffer: Buffer) -> MemoryDedicatedAllocateInfoBuilder<'a>23395     pub fn buffer(mut self, buffer: Buffer) -> MemoryDedicatedAllocateInfoBuilder<'a> {
23396         self.inner.buffer = buffer;
23397         self
23398     }
23399     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23400     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23401     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryDedicatedAllocateInfo23402     pub fn build(self) -> MemoryDedicatedAllocateInfo {
23403         self.inner
23404     }
23405 }
23406 #[repr(C)]
23407 #[derive(Copy, Clone, Debug)]
23408 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewUsageCreateInfo.html>"]
23409 pub struct ImageViewUsageCreateInfo {
23410     pub s_type: StructureType,
23411     pub p_next: *const c_void,
23412     pub usage: ImageUsageFlags,
23413 }
23414 impl ::std::default::Default for ImageViewUsageCreateInfo {
default() -> ImageViewUsageCreateInfo23415     fn default() -> ImageViewUsageCreateInfo {
23416         ImageViewUsageCreateInfo {
23417             s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO,
23418             p_next: ::std::ptr::null(),
23419             usage: ImageUsageFlags::default(),
23420         }
23421     }
23422 }
23423 impl ImageViewUsageCreateInfo {
builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a>23424     pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> {
23425         ImageViewUsageCreateInfoBuilder {
23426             inner: ImageViewUsageCreateInfo::default(),
23427             marker: ::std::marker::PhantomData,
23428         }
23429     }
23430 }
23431 #[repr(transparent)]
23432 pub struct ImageViewUsageCreateInfoBuilder<'a> {
23433     inner: ImageViewUsageCreateInfo,
23434     marker: ::std::marker::PhantomData<&'a ()>,
23435 }
23436 unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {}
23437 unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {}
23438 impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> {
23439     type Target = ImageViewUsageCreateInfo;
deref(&self) -> &Self::Target23440     fn deref(&self) -> &Self::Target {
23441         &self.inner
23442     }
23443 }
23444 impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23445     fn deref_mut(&mut self) -> &mut Self::Target {
23446         &mut self.inner
23447     }
23448 }
23449 impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
usage(mut self, usage: ImageUsageFlags) -> ImageViewUsageCreateInfoBuilder<'a>23450     pub fn usage(mut self, usage: ImageUsageFlags) -> ImageViewUsageCreateInfoBuilder<'a> {
23451         self.inner.usage = usage;
23452         self
23453     }
23454     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23455     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23456     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewUsageCreateInfo23457     pub fn build(self) -> ImageViewUsageCreateInfo {
23458         self.inner
23459     }
23460 }
23461 #[repr(C)]
23462 #[derive(Copy, Clone, Debug)]
23463 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>"]
23464 pub struct PipelineTessellationDomainOriginStateCreateInfo {
23465     pub s_type: StructureType,
23466     pub p_next: *const c_void,
23467     pub domain_origin: TessellationDomainOrigin,
23468 }
23469 impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo {
default() -> PipelineTessellationDomainOriginStateCreateInfo23470     fn default() -> PipelineTessellationDomainOriginStateCreateInfo {
23471         PipelineTessellationDomainOriginStateCreateInfo {
23472             s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
23473             p_next: ::std::ptr::null(),
23474             domain_origin: TessellationDomainOrigin::default(),
23475         }
23476     }
23477 }
23478 impl PipelineTessellationDomainOriginStateCreateInfo {
builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a>23479     pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
23480         PipelineTessellationDomainOriginStateCreateInfoBuilder {
23481             inner: PipelineTessellationDomainOriginStateCreateInfo::default(),
23482             marker: ::std::marker::PhantomData,
23483         }
23484     }
23485 }
23486 #[repr(transparent)]
23487 pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
23488     inner: PipelineTessellationDomainOriginStateCreateInfo,
23489     marker: ::std::marker::PhantomData<&'a ()>,
23490 }
23491 unsafe impl ExtendsPipelineTessellationStateCreateInfo
23492     for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_>
23493 {
23494 }
23495 unsafe impl ExtendsPipelineTessellationStateCreateInfo
23496     for PipelineTessellationDomainOriginStateCreateInfo
23497 {
23498 }
23499 impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
23500     type Target = PipelineTessellationDomainOriginStateCreateInfo;
deref(&self) -> &Self::Target23501     fn deref(&self) -> &Self::Target {
23502         &self.inner
23503     }
23504 }
23505 impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23506     fn deref_mut(&mut self) -> &mut Self::Target {
23507         &mut self.inner
23508     }
23509 }
23510 impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
domain_origin( mut self, domain_origin: TessellationDomainOrigin, ) -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a>23511     pub fn domain_origin(
23512         mut self,
23513         domain_origin: TessellationDomainOrigin,
23514     ) -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
23515         self.inner.domain_origin = domain_origin;
23516         self
23517     }
23518     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23519     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23520     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineTessellationDomainOriginStateCreateInfo23521     pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo {
23522         self.inner
23523     }
23524 }
23525 #[repr(C)]
23526 #[derive(Copy, Clone, Debug)]
23527 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionInfo.html>"]
23528 pub struct SamplerYcbcrConversionInfo {
23529     pub s_type: StructureType,
23530     pub p_next: *const c_void,
23531     pub conversion: SamplerYcbcrConversion,
23532 }
23533 impl ::std::default::Default for SamplerYcbcrConversionInfo {
default() -> SamplerYcbcrConversionInfo23534     fn default() -> SamplerYcbcrConversionInfo {
23535         SamplerYcbcrConversionInfo {
23536             s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO,
23537             p_next: ::std::ptr::null(),
23538             conversion: SamplerYcbcrConversion::default(),
23539         }
23540     }
23541 }
23542 impl SamplerYcbcrConversionInfo {
builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a>23543     pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> {
23544         SamplerYcbcrConversionInfoBuilder {
23545             inner: SamplerYcbcrConversionInfo::default(),
23546             marker: ::std::marker::PhantomData,
23547         }
23548     }
23549 }
23550 #[repr(transparent)]
23551 pub struct SamplerYcbcrConversionInfoBuilder<'a> {
23552     inner: SamplerYcbcrConversionInfo,
23553     marker: ::std::marker::PhantomData<&'a ()>,
23554 }
23555 unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
23556 unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {}
23557 unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
23558 unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {}
23559 impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> {
23560     type Target = SamplerYcbcrConversionInfo;
deref(&self) -> &Self::Target23561     fn deref(&self) -> &Self::Target {
23562         &self.inner
23563     }
23564 }
23565 impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23566     fn deref_mut(&mut self) -> &mut Self::Target {
23567         &mut self.inner
23568     }
23569 }
23570 impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
conversion( mut self, conversion: SamplerYcbcrConversion, ) -> SamplerYcbcrConversionInfoBuilder<'a>23571     pub fn conversion(
23572         mut self,
23573         conversion: SamplerYcbcrConversion,
23574     ) -> SamplerYcbcrConversionInfoBuilder<'a> {
23575         self.inner.conversion = conversion;
23576         self
23577     }
23578     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23579     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23580     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerYcbcrConversionInfo23581     pub fn build(self) -> SamplerYcbcrConversionInfo {
23582         self.inner
23583     }
23584 }
23585 #[repr(C)]
23586 #[derive(Copy, Clone, Debug)]
23587 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html>"]
23588 pub struct SamplerYcbcrConversionCreateInfo {
23589     pub s_type: StructureType,
23590     pub p_next: *const c_void,
23591     pub format: Format,
23592     pub ycbcr_model: SamplerYcbcrModelConversion,
23593     pub ycbcr_range: SamplerYcbcrRange,
23594     pub components: ComponentMapping,
23595     pub x_chroma_offset: ChromaLocation,
23596     pub y_chroma_offset: ChromaLocation,
23597     pub chroma_filter: Filter,
23598     pub force_explicit_reconstruction: Bool32,
23599 }
23600 impl ::std::default::Default for SamplerYcbcrConversionCreateInfo {
default() -> SamplerYcbcrConversionCreateInfo23601     fn default() -> SamplerYcbcrConversionCreateInfo {
23602         SamplerYcbcrConversionCreateInfo {
23603             s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
23604             p_next: ::std::ptr::null(),
23605             format: Format::default(),
23606             ycbcr_model: SamplerYcbcrModelConversion::default(),
23607             ycbcr_range: SamplerYcbcrRange::default(),
23608             components: ComponentMapping::default(),
23609             x_chroma_offset: ChromaLocation::default(),
23610             y_chroma_offset: ChromaLocation::default(),
23611             chroma_filter: Filter::default(),
23612             force_explicit_reconstruction: Bool32::default(),
23613         }
23614     }
23615 }
23616 impl SamplerYcbcrConversionCreateInfo {
builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a>23617     pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23618         SamplerYcbcrConversionCreateInfoBuilder {
23619             inner: SamplerYcbcrConversionCreateInfo::default(),
23620             marker: ::std::marker::PhantomData,
23621         }
23622     }
23623 }
23624 #[repr(transparent)]
23625 pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> {
23626     inner: SamplerYcbcrConversionCreateInfo,
23627     marker: ::std::marker::PhantomData<&'a ()>,
23628 }
23629 pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {}
23630 impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> {
23631     type Target = SamplerYcbcrConversionCreateInfo;
deref(&self) -> &Self::Target23632     fn deref(&self) -> &Self::Target {
23633         &self.inner
23634     }
23635 }
23636 impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23637     fn deref_mut(&mut self) -> &mut Self::Target {
23638         &mut self.inner
23639     }
23640 }
23641 impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
format(mut self, format: Format) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23642     pub fn format(mut self, format: Format) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23643         self.inner.format = format;
23644         self
23645     }
ycbcr_model( mut self, ycbcr_model: SamplerYcbcrModelConversion, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23646     pub fn ycbcr_model(
23647         mut self,
23648         ycbcr_model: SamplerYcbcrModelConversion,
23649     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23650         self.inner.ycbcr_model = ycbcr_model;
23651         self
23652     }
ycbcr_range( mut self, ycbcr_range: SamplerYcbcrRange, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23653     pub fn ycbcr_range(
23654         mut self,
23655         ycbcr_range: SamplerYcbcrRange,
23656     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23657         self.inner.ycbcr_range = ycbcr_range;
23658         self
23659     }
components( mut self, components: ComponentMapping, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23660     pub fn components(
23661         mut self,
23662         components: ComponentMapping,
23663     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23664         self.inner.components = components;
23665         self
23666     }
x_chroma_offset( mut self, x_chroma_offset: ChromaLocation, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23667     pub fn x_chroma_offset(
23668         mut self,
23669         x_chroma_offset: ChromaLocation,
23670     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23671         self.inner.x_chroma_offset = x_chroma_offset;
23672         self
23673     }
y_chroma_offset( mut self, y_chroma_offset: ChromaLocation, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23674     pub fn y_chroma_offset(
23675         mut self,
23676         y_chroma_offset: ChromaLocation,
23677     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23678         self.inner.y_chroma_offset = y_chroma_offset;
23679         self
23680     }
chroma_filter( mut self, chroma_filter: Filter, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23681     pub fn chroma_filter(
23682         mut self,
23683         chroma_filter: Filter,
23684     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23685         self.inner.chroma_filter = chroma_filter;
23686         self
23687     }
force_explicit_reconstruction( mut self, force_explicit_reconstruction: bool, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23688     pub fn force_explicit_reconstruction(
23689         mut self,
23690         force_explicit_reconstruction: bool,
23691     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23692         self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into();
23693         self
23694     }
23695     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
23696     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
23697     #[doc = r" valid extension structs can be pushed into the chain."]
23698     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
23699     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>( mut self, next: &'a mut T, ) -> SamplerYcbcrConversionCreateInfoBuilder<'a>23700     pub fn push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>(
23701         mut self,
23702         next: &'a mut T,
23703     ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
23704         unsafe {
23705             let next_ptr = next as *mut T as *mut BaseOutStructure;
23706             let last_next = ptr_chain_iter(next).last().unwrap();
23707             (*last_next).p_next = self.inner.p_next as _;
23708             self.inner.p_next = next_ptr as _;
23709         }
23710         self
23711     }
23712     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23713     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23714     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerYcbcrConversionCreateInfo23715     pub fn build(self) -> SamplerYcbcrConversionCreateInfo {
23716         self.inner
23717     }
23718 }
23719 #[repr(C)]
23720 #[derive(Copy, Clone, Debug)]
23721 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImagePlaneMemoryInfo.html>"]
23722 pub struct BindImagePlaneMemoryInfo {
23723     pub s_type: StructureType,
23724     pub p_next: *const c_void,
23725     pub plane_aspect: ImageAspectFlags,
23726 }
23727 impl ::std::default::Default for BindImagePlaneMemoryInfo {
default() -> BindImagePlaneMemoryInfo23728     fn default() -> BindImagePlaneMemoryInfo {
23729         BindImagePlaneMemoryInfo {
23730             s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO,
23731             p_next: ::std::ptr::null(),
23732             plane_aspect: ImageAspectFlags::default(),
23733         }
23734     }
23735 }
23736 impl BindImagePlaneMemoryInfo {
builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a>23737     pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> {
23738         BindImagePlaneMemoryInfoBuilder {
23739             inner: BindImagePlaneMemoryInfo::default(),
23740             marker: ::std::marker::PhantomData,
23741         }
23742     }
23743 }
23744 #[repr(transparent)]
23745 pub struct BindImagePlaneMemoryInfoBuilder<'a> {
23746     inner: BindImagePlaneMemoryInfo,
23747     marker: ::std::marker::PhantomData<&'a ()>,
23748 }
23749 unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {}
23750 unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {}
23751 impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> {
23752     type Target = BindImagePlaneMemoryInfo;
deref(&self) -> &Self::Target23753     fn deref(&self) -> &Self::Target {
23754         &self.inner
23755     }
23756 }
23757 impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23758     fn deref_mut(&mut self) -> &mut Self::Target {
23759         &mut self.inner
23760     }
23761 }
23762 impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
plane_aspect( mut self, plane_aspect: ImageAspectFlags, ) -> BindImagePlaneMemoryInfoBuilder<'a>23763     pub fn plane_aspect(
23764         mut self,
23765         plane_aspect: ImageAspectFlags,
23766     ) -> BindImagePlaneMemoryInfoBuilder<'a> {
23767         self.inner.plane_aspect = plane_aspect;
23768         self
23769     }
23770     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23771     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23772     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindImagePlaneMemoryInfo23773     pub fn build(self) -> BindImagePlaneMemoryInfo {
23774         self.inner
23775     }
23776 }
23777 #[repr(C)]
23778 #[derive(Copy, Clone, Debug)]
23779 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html>"]
23780 pub struct ImagePlaneMemoryRequirementsInfo {
23781     pub s_type: StructureType,
23782     pub p_next: *const c_void,
23783     pub plane_aspect: ImageAspectFlags,
23784 }
23785 impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo {
default() -> ImagePlaneMemoryRequirementsInfo23786     fn default() -> ImagePlaneMemoryRequirementsInfo {
23787         ImagePlaneMemoryRequirementsInfo {
23788             s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
23789             p_next: ::std::ptr::null(),
23790             plane_aspect: ImageAspectFlags::default(),
23791         }
23792     }
23793 }
23794 impl ImagePlaneMemoryRequirementsInfo {
builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a>23795     pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
23796         ImagePlaneMemoryRequirementsInfoBuilder {
23797             inner: ImagePlaneMemoryRequirementsInfo::default(),
23798             marker: ::std::marker::PhantomData,
23799         }
23800     }
23801 }
23802 #[repr(transparent)]
23803 pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> {
23804     inner: ImagePlaneMemoryRequirementsInfo,
23805     marker: ::std::marker::PhantomData<&'a ()>,
23806 }
23807 unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {}
23808 unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {}
23809 impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
23810     type Target = ImagePlaneMemoryRequirementsInfo;
deref(&self) -> &Self::Target23811     fn deref(&self) -> &Self::Target {
23812         &self.inner
23813     }
23814 }
23815 impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23816     fn deref_mut(&mut self) -> &mut Self::Target {
23817         &mut self.inner
23818     }
23819 }
23820 impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
plane_aspect( mut self, plane_aspect: ImageAspectFlags, ) -> ImagePlaneMemoryRequirementsInfoBuilder<'a>23821     pub fn plane_aspect(
23822         mut self,
23823         plane_aspect: ImageAspectFlags,
23824     ) -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
23825         self.inner.plane_aspect = plane_aspect;
23826         self
23827     }
23828     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23829     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23830     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImagePlaneMemoryRequirementsInfo23831     pub fn build(self) -> ImagePlaneMemoryRequirementsInfo {
23832         self.inner
23833     }
23834 }
23835 #[repr(C)]
23836 #[derive(Copy, Clone, Debug)]
23837 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>"]
23838 pub struct PhysicalDeviceSamplerYcbcrConversionFeatures {
23839     pub s_type: StructureType,
23840     pub p_next: *mut c_void,
23841     pub sampler_ycbcr_conversion: Bool32,
23842 }
23843 impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures {
default() -> PhysicalDeviceSamplerYcbcrConversionFeatures23844     fn default() -> PhysicalDeviceSamplerYcbcrConversionFeatures {
23845         PhysicalDeviceSamplerYcbcrConversionFeatures {
23846             s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
23847             p_next: ::std::ptr::null_mut(),
23848             sampler_ycbcr_conversion: Bool32::default(),
23849         }
23850     }
23851 }
23852 impl PhysicalDeviceSamplerYcbcrConversionFeatures {
builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a>23853     pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
23854         PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder {
23855             inner: PhysicalDeviceSamplerYcbcrConversionFeatures::default(),
23856             marker: ::std::marker::PhantomData,
23857         }
23858     }
23859 }
23860 #[repr(transparent)]
23861 pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
23862     inner: PhysicalDeviceSamplerYcbcrConversionFeatures,
23863     marker: ::std::marker::PhantomData<&'a ()>,
23864 }
23865 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {}
23866 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {}
23867 impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
23868     type Target = PhysicalDeviceSamplerYcbcrConversionFeatures;
deref(&self) -> &Self::Target23869     fn deref(&self) -> &Self::Target {
23870         &self.inner
23871     }
23872 }
23873 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23874     fn deref_mut(&mut self) -> &mut Self::Target {
23875         &mut self.inner
23876     }
23877 }
23878 impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
sampler_ycbcr_conversion( mut self, sampler_ycbcr_conversion: bool, ) -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a>23879     pub fn sampler_ycbcr_conversion(
23880         mut self,
23881         sampler_ycbcr_conversion: bool,
23882     ) -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
23883         self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
23884         self
23885     }
23886     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23887     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23888     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures23889     pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures {
23890         self.inner
23891     }
23892 }
23893 #[repr(C)]
23894 #[derive(Copy, Clone, Debug)]
23895 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>"]
23896 pub struct SamplerYcbcrConversionImageFormatProperties {
23897     pub s_type: StructureType,
23898     pub p_next: *mut c_void,
23899     pub combined_image_sampler_descriptor_count: u32,
23900 }
23901 impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties {
default() -> SamplerYcbcrConversionImageFormatProperties23902     fn default() -> SamplerYcbcrConversionImageFormatProperties {
23903         SamplerYcbcrConversionImageFormatProperties {
23904             s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
23905             p_next: ::std::ptr::null_mut(),
23906             combined_image_sampler_descriptor_count: u32::default(),
23907         }
23908     }
23909 }
23910 impl SamplerYcbcrConversionImageFormatProperties {
builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a>23911     pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
23912         SamplerYcbcrConversionImageFormatPropertiesBuilder {
23913             inner: SamplerYcbcrConversionImageFormatProperties::default(),
23914             marker: ::std::marker::PhantomData,
23915         }
23916     }
23917 }
23918 #[repr(transparent)]
23919 pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
23920     inner: SamplerYcbcrConversionImageFormatProperties,
23921     marker: ::std::marker::PhantomData<&'a ()>,
23922 }
23923 unsafe impl ExtendsImageFormatProperties2
23924     for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_>
23925 {
23926 }
23927 unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {}
23928 impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
23929     type Target = SamplerYcbcrConversionImageFormatProperties;
deref(&self) -> &Self::Target23930     fn deref(&self) -> &Self::Target {
23931         &self.inner
23932     }
23933 }
23934 impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23935     fn deref_mut(&mut self) -> &mut Self::Target {
23936         &mut self.inner
23937     }
23938 }
23939 impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
combined_image_sampler_descriptor_count( mut self, combined_image_sampler_descriptor_count: u32, ) -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a>23940     pub fn combined_image_sampler_descriptor_count(
23941         mut self,
23942         combined_image_sampler_descriptor_count: u32,
23943     ) -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
23944         self.inner.combined_image_sampler_descriptor_count =
23945             combined_image_sampler_descriptor_count;
23946         self
23947     }
23948     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
23949     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
23950     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerYcbcrConversionImageFormatProperties23951     pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties {
23952         self.inner
23953     }
23954 }
23955 #[repr(C)]
23956 #[derive(Copy, Clone, Debug)]
23957 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html>"]
23958 pub struct TextureLODGatherFormatPropertiesAMD {
23959     pub s_type: StructureType,
23960     pub p_next: *mut c_void,
23961     pub supports_texture_gather_lod_bias_amd: Bool32,
23962 }
23963 impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD {
default() -> TextureLODGatherFormatPropertiesAMD23964     fn default() -> TextureLODGatherFormatPropertiesAMD {
23965         TextureLODGatherFormatPropertiesAMD {
23966             s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
23967             p_next: ::std::ptr::null_mut(),
23968             supports_texture_gather_lod_bias_amd: Bool32::default(),
23969         }
23970     }
23971 }
23972 impl TextureLODGatherFormatPropertiesAMD {
builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a>23973     pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
23974         TextureLODGatherFormatPropertiesAMDBuilder {
23975             inner: TextureLODGatherFormatPropertiesAMD::default(),
23976             marker: ::std::marker::PhantomData,
23977         }
23978     }
23979 }
23980 #[repr(transparent)]
23981 pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> {
23982     inner: TextureLODGatherFormatPropertiesAMD,
23983     marker: ::std::marker::PhantomData<&'a ()>,
23984 }
23985 unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {}
23986 unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {}
23987 impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
23988     type Target = TextureLODGatherFormatPropertiesAMD;
deref(&self) -> &Self::Target23989     fn deref(&self) -> &Self::Target {
23990         &self.inner
23991     }
23992 }
23993 impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target23994     fn deref_mut(&mut self) -> &mut Self::Target {
23995         &mut self.inner
23996     }
23997 }
23998 impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
supports_texture_gather_lod_bias_amd( mut self, supports_texture_gather_lod_bias_amd: bool, ) -> TextureLODGatherFormatPropertiesAMDBuilder<'a>23999     pub fn supports_texture_gather_lod_bias_amd(
24000         mut self,
24001         supports_texture_gather_lod_bias_amd: bool,
24002     ) -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
24003         self.inner.supports_texture_gather_lod_bias_amd =
24004             supports_texture_gather_lod_bias_amd.into();
24005         self
24006     }
24007     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24008     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24009     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TextureLODGatherFormatPropertiesAMD24010     pub fn build(self) -> TextureLODGatherFormatPropertiesAMD {
24011         self.inner
24012     }
24013 }
24014 #[repr(C)]
24015 #[derive(Copy, Clone, Debug)]
24016 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html>"]
24017 pub struct ConditionalRenderingBeginInfoEXT {
24018     pub s_type: StructureType,
24019     pub p_next: *const c_void,
24020     pub buffer: Buffer,
24021     pub offset: DeviceSize,
24022     pub flags: ConditionalRenderingFlagsEXT,
24023 }
24024 impl ::std::default::Default for ConditionalRenderingBeginInfoEXT {
default() -> ConditionalRenderingBeginInfoEXT24025     fn default() -> ConditionalRenderingBeginInfoEXT {
24026         ConditionalRenderingBeginInfoEXT {
24027             s_type: StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
24028             p_next: ::std::ptr::null(),
24029             buffer: Buffer::default(),
24030             offset: DeviceSize::default(),
24031             flags: ConditionalRenderingFlagsEXT::default(),
24032         }
24033     }
24034 }
24035 impl ConditionalRenderingBeginInfoEXT {
builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a>24036     pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
24037         ConditionalRenderingBeginInfoEXTBuilder {
24038             inner: ConditionalRenderingBeginInfoEXT::default(),
24039             marker: ::std::marker::PhantomData,
24040         }
24041     }
24042 }
24043 #[repr(transparent)]
24044 pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> {
24045     inner: ConditionalRenderingBeginInfoEXT,
24046     marker: ::std::marker::PhantomData<&'a ()>,
24047 }
24048 pub unsafe trait ExtendsConditionalRenderingBeginInfoEXT {}
24049 impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> {
24050     type Target = ConditionalRenderingBeginInfoEXT;
deref(&self) -> &Self::Target24051     fn deref(&self) -> &Self::Target {
24052         &self.inner
24053     }
24054 }
24055 impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24056     fn deref_mut(&mut self) -> &mut Self::Target {
24057         &mut self.inner
24058     }
24059 }
24060 impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
buffer(mut self, buffer: Buffer) -> ConditionalRenderingBeginInfoEXTBuilder<'a>24061     pub fn buffer(mut self, buffer: Buffer) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
24062         self.inner.buffer = buffer;
24063         self
24064     }
offset(mut self, offset: DeviceSize) -> ConditionalRenderingBeginInfoEXTBuilder<'a>24065     pub fn offset(mut self, offset: DeviceSize) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
24066         self.inner.offset = offset;
24067         self
24068     }
flags( mut self, flags: ConditionalRenderingFlagsEXT, ) -> ConditionalRenderingBeginInfoEXTBuilder<'a>24069     pub fn flags(
24070         mut self,
24071         flags: ConditionalRenderingFlagsEXT,
24072     ) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
24073         self.inner.flags = flags;
24074         self
24075     }
24076     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
24077     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
24078     #[doc = r" valid extension structs can be pushed into the chain."]
24079     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
24080     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsConditionalRenderingBeginInfoEXT>( mut self, next: &'a mut T, ) -> ConditionalRenderingBeginInfoEXTBuilder<'a>24081     pub fn push_next<T: ExtendsConditionalRenderingBeginInfoEXT>(
24082         mut self,
24083         next: &'a mut T,
24084     ) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
24085         unsafe {
24086             let next_ptr = next as *mut T as *mut BaseOutStructure;
24087             let last_next = ptr_chain_iter(next).last().unwrap();
24088             (*last_next).p_next = self.inner.p_next as _;
24089             self.inner.p_next = next_ptr as _;
24090         }
24091         self
24092     }
24093     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24094     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24095     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ConditionalRenderingBeginInfoEXT24096     pub fn build(self) -> ConditionalRenderingBeginInfoEXT {
24097         self.inner
24098     }
24099 }
24100 #[repr(C)]
24101 #[derive(Copy, Clone, Debug)]
24102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkProtectedSubmitInfo.html>"]
24103 pub struct ProtectedSubmitInfo {
24104     pub s_type: StructureType,
24105     pub p_next: *const c_void,
24106     pub protected_submit: Bool32,
24107 }
24108 impl ::std::default::Default for ProtectedSubmitInfo {
default() -> ProtectedSubmitInfo24109     fn default() -> ProtectedSubmitInfo {
24110         ProtectedSubmitInfo {
24111             s_type: StructureType::PROTECTED_SUBMIT_INFO,
24112             p_next: ::std::ptr::null(),
24113             protected_submit: Bool32::default(),
24114         }
24115     }
24116 }
24117 impl ProtectedSubmitInfo {
builder<'a>() -> ProtectedSubmitInfoBuilder<'a>24118     pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> {
24119         ProtectedSubmitInfoBuilder {
24120             inner: ProtectedSubmitInfo::default(),
24121             marker: ::std::marker::PhantomData,
24122         }
24123     }
24124 }
24125 #[repr(transparent)]
24126 pub struct ProtectedSubmitInfoBuilder<'a> {
24127     inner: ProtectedSubmitInfo,
24128     marker: ::std::marker::PhantomData<&'a ()>,
24129 }
24130 unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {}
24131 unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {}
24132 impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> {
24133     type Target = ProtectedSubmitInfo;
deref(&self) -> &Self::Target24134     fn deref(&self) -> &Self::Target {
24135         &self.inner
24136     }
24137 }
24138 impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24139     fn deref_mut(&mut self) -> &mut Self::Target {
24140         &mut self.inner
24141     }
24142 }
24143 impl<'a> ProtectedSubmitInfoBuilder<'a> {
protected_submit(mut self, protected_submit: bool) -> ProtectedSubmitInfoBuilder<'a>24144     pub fn protected_submit(mut self, protected_submit: bool) -> ProtectedSubmitInfoBuilder<'a> {
24145         self.inner.protected_submit = protected_submit.into();
24146         self
24147     }
24148     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24149     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24150     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ProtectedSubmitInfo24151     pub fn build(self) -> ProtectedSubmitInfo {
24152         self.inner
24153     }
24154 }
24155 #[repr(C)]
24156 #[derive(Copy, Clone, Debug)]
24157 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>"]
24158 pub struct PhysicalDeviceProtectedMemoryFeatures {
24159     pub s_type: StructureType,
24160     pub p_next: *mut c_void,
24161     pub protected_memory: Bool32,
24162 }
24163 impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures {
default() -> PhysicalDeviceProtectedMemoryFeatures24164     fn default() -> PhysicalDeviceProtectedMemoryFeatures {
24165         PhysicalDeviceProtectedMemoryFeatures {
24166             s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
24167             p_next: ::std::ptr::null_mut(),
24168             protected_memory: Bool32::default(),
24169         }
24170     }
24171 }
24172 impl PhysicalDeviceProtectedMemoryFeatures {
builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a>24173     pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24174         PhysicalDeviceProtectedMemoryFeaturesBuilder {
24175             inner: PhysicalDeviceProtectedMemoryFeatures::default(),
24176             marker: ::std::marker::PhantomData,
24177         }
24178     }
24179 }
24180 #[repr(transparent)]
24181 pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24182     inner: PhysicalDeviceProtectedMemoryFeatures,
24183     marker: ::std::marker::PhantomData<&'a ()>,
24184 }
24185 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
24186 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {}
24187 impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24188     type Target = PhysicalDeviceProtectedMemoryFeatures;
deref(&self) -> &Self::Target24189     fn deref(&self) -> &Self::Target {
24190         &self.inner
24191     }
24192 }
24193 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24194     fn deref_mut(&mut self) -> &mut Self::Target {
24195         &mut self.inner
24196     }
24197 }
24198 impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
protected_memory( mut self, protected_memory: bool, ) -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a>24199     pub fn protected_memory(
24200         mut self,
24201         protected_memory: bool,
24202     ) -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
24203         self.inner.protected_memory = protected_memory.into();
24204         self
24205     }
24206     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24207     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24208     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProtectedMemoryFeatures24209     pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures {
24210         self.inner
24211     }
24212 }
24213 #[repr(C)]
24214 #[derive(Copy, Clone, Debug)]
24215 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>"]
24216 pub struct PhysicalDeviceProtectedMemoryProperties {
24217     pub s_type: StructureType,
24218     pub p_next: *mut c_void,
24219     pub protected_no_fault: Bool32,
24220 }
24221 impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties {
default() -> PhysicalDeviceProtectedMemoryProperties24222     fn default() -> PhysicalDeviceProtectedMemoryProperties {
24223         PhysicalDeviceProtectedMemoryProperties {
24224             s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
24225             p_next: ::std::ptr::null_mut(),
24226             protected_no_fault: Bool32::default(),
24227         }
24228     }
24229 }
24230 impl PhysicalDeviceProtectedMemoryProperties {
builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a>24231     pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24232         PhysicalDeviceProtectedMemoryPropertiesBuilder {
24233             inner: PhysicalDeviceProtectedMemoryProperties::default(),
24234             marker: ::std::marker::PhantomData,
24235         }
24236     }
24237 }
24238 #[repr(transparent)]
24239 pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24240     inner: PhysicalDeviceProtectedMemoryProperties,
24241     marker: ::std::marker::PhantomData<&'a ()>,
24242 }
24243 unsafe impl ExtendsPhysicalDeviceProperties2
24244     for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_>
24245 {
24246 }
24247 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {}
24248 impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24249     type Target = PhysicalDeviceProtectedMemoryProperties;
deref(&self) -> &Self::Target24250     fn deref(&self) -> &Self::Target {
24251         &self.inner
24252     }
24253 }
24254 impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24255     fn deref_mut(&mut self) -> &mut Self::Target {
24256         &mut self.inner
24257     }
24258 }
24259 impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
protected_no_fault( mut self, protected_no_fault: bool, ) -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a>24260     pub fn protected_no_fault(
24261         mut self,
24262         protected_no_fault: bool,
24263     ) -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
24264         self.inner.protected_no_fault = protected_no_fault.into();
24265         self
24266     }
24267     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24268     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24269     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceProtectedMemoryProperties24270     pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties {
24271         self.inner
24272     }
24273 }
24274 #[repr(C)]
24275 #[derive(Copy, Clone, Debug)]
24276 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueInfo2.html>"]
24277 pub struct DeviceQueueInfo2 {
24278     pub s_type: StructureType,
24279     pub p_next: *const c_void,
24280     pub flags: DeviceQueueCreateFlags,
24281     pub queue_family_index: u32,
24282     pub queue_index: u32,
24283 }
24284 impl ::std::default::Default for DeviceQueueInfo2 {
default() -> DeviceQueueInfo224285     fn default() -> DeviceQueueInfo2 {
24286         DeviceQueueInfo2 {
24287             s_type: StructureType::DEVICE_QUEUE_INFO_2,
24288             p_next: ::std::ptr::null(),
24289             flags: DeviceQueueCreateFlags::default(),
24290             queue_family_index: u32::default(),
24291             queue_index: u32::default(),
24292         }
24293     }
24294 }
24295 impl DeviceQueueInfo2 {
builder<'a>() -> DeviceQueueInfo2Builder<'a>24296     pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> {
24297         DeviceQueueInfo2Builder {
24298             inner: DeviceQueueInfo2::default(),
24299             marker: ::std::marker::PhantomData,
24300         }
24301     }
24302 }
24303 #[repr(transparent)]
24304 pub struct DeviceQueueInfo2Builder<'a> {
24305     inner: DeviceQueueInfo2,
24306     marker: ::std::marker::PhantomData<&'a ()>,
24307 }
24308 pub unsafe trait ExtendsDeviceQueueInfo2 {}
24309 impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> {
24310     type Target = DeviceQueueInfo2;
deref(&self) -> &Self::Target24311     fn deref(&self) -> &Self::Target {
24312         &self.inner
24313     }
24314 }
24315 impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target24316     fn deref_mut(&mut self) -> &mut Self::Target {
24317         &mut self.inner
24318     }
24319 }
24320 impl<'a> DeviceQueueInfo2Builder<'a> {
flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueInfo2Builder<'a>24321     pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueInfo2Builder<'a> {
24322         self.inner.flags = flags;
24323         self
24324     }
queue_family_index(mut self, queue_family_index: u32) -> DeviceQueueInfo2Builder<'a>24325     pub fn queue_family_index(mut self, queue_family_index: u32) -> DeviceQueueInfo2Builder<'a> {
24326         self.inner.queue_family_index = queue_family_index;
24327         self
24328     }
queue_index(mut self, queue_index: u32) -> DeviceQueueInfo2Builder<'a>24329     pub fn queue_index(mut self, queue_index: u32) -> DeviceQueueInfo2Builder<'a> {
24330         self.inner.queue_index = queue_index;
24331         self
24332     }
24333     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
24334     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
24335     #[doc = r" valid extension structs can be pushed into the chain."]
24336     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
24337     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceQueueInfo2>( mut self, next: &'a mut T, ) -> DeviceQueueInfo2Builder<'a>24338     pub fn push_next<T: ExtendsDeviceQueueInfo2>(
24339         mut self,
24340         next: &'a mut T,
24341     ) -> DeviceQueueInfo2Builder<'a> {
24342         unsafe {
24343             let next_ptr = next as *mut T as *mut BaseOutStructure;
24344             let last_next = ptr_chain_iter(next).last().unwrap();
24345             (*last_next).p_next = self.inner.p_next as _;
24346             self.inner.p_next = next_ptr as _;
24347         }
24348         self
24349     }
24350     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24351     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24352     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceQueueInfo224353     pub fn build(self) -> DeviceQueueInfo2 {
24354         self.inner
24355     }
24356 }
24357 #[repr(C)]
24358 #[derive(Copy, Clone, Debug)]
24359 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>"]
24360 pub struct PipelineCoverageToColorStateCreateInfoNV {
24361     pub s_type: StructureType,
24362     pub p_next: *const c_void,
24363     pub flags: PipelineCoverageToColorStateCreateFlagsNV,
24364     pub coverage_to_color_enable: Bool32,
24365     pub coverage_to_color_location: u32,
24366 }
24367 impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV {
default() -> PipelineCoverageToColorStateCreateInfoNV24368     fn default() -> PipelineCoverageToColorStateCreateInfoNV {
24369         PipelineCoverageToColorStateCreateInfoNV {
24370             s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
24371             p_next: ::std::ptr::null(),
24372             flags: PipelineCoverageToColorStateCreateFlagsNV::default(),
24373             coverage_to_color_enable: Bool32::default(),
24374             coverage_to_color_location: u32::default(),
24375         }
24376     }
24377 }
24378 impl PipelineCoverageToColorStateCreateInfoNV {
builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a>24379     pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24380         PipelineCoverageToColorStateCreateInfoNVBuilder {
24381             inner: PipelineCoverageToColorStateCreateInfoNV::default(),
24382             marker: ::std::marker::PhantomData,
24383         }
24384     }
24385 }
24386 #[repr(transparent)]
24387 pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24388     inner: PipelineCoverageToColorStateCreateInfoNV,
24389     marker: ::std::marker::PhantomData<&'a ()>,
24390 }
24391 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
24392     for PipelineCoverageToColorStateCreateInfoNVBuilder<'_>
24393 {
24394 }
24395 unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {}
24396 impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24397     type Target = PipelineCoverageToColorStateCreateInfoNV;
deref(&self) -> &Self::Target24398     fn deref(&self) -> &Self::Target {
24399         &self.inner
24400     }
24401 }
24402 impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24403     fn deref_mut(&mut self) -> &mut Self::Target {
24404         &mut self.inner
24405     }
24406 }
24407 impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
flags( mut self, flags: PipelineCoverageToColorStateCreateFlagsNV, ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a>24408     pub fn flags(
24409         mut self,
24410         flags: PipelineCoverageToColorStateCreateFlagsNV,
24411     ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24412         self.inner.flags = flags;
24413         self
24414     }
coverage_to_color_enable( mut self, coverage_to_color_enable: bool, ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a>24415     pub fn coverage_to_color_enable(
24416         mut self,
24417         coverage_to_color_enable: bool,
24418     ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24419         self.inner.coverage_to_color_enable = coverage_to_color_enable.into();
24420         self
24421     }
coverage_to_color_location( mut self, coverage_to_color_location: u32, ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a>24422     pub fn coverage_to_color_location(
24423         mut self,
24424         coverage_to_color_location: u32,
24425     ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
24426         self.inner.coverage_to_color_location = coverage_to_color_location;
24427         self
24428     }
24429     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24430     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24431     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCoverageToColorStateCreateInfoNV24432     pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV {
24433         self.inner
24434     }
24435 }
24436 #[repr(C)]
24437 #[derive(Copy, Clone, Debug)]
24438 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>"]
24439 pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
24440     pub s_type: StructureType,
24441     pub p_next: *mut c_void,
24442     pub filter_minmax_single_component_formats: Bool32,
24443     pub filter_minmax_image_component_mapping: Bool32,
24444 }
24445 impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties {
default() -> PhysicalDeviceSamplerFilterMinmaxProperties24446     fn default() -> PhysicalDeviceSamplerFilterMinmaxProperties {
24447         PhysicalDeviceSamplerFilterMinmaxProperties {
24448             s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
24449             p_next: ::std::ptr::null_mut(),
24450             filter_minmax_single_component_formats: Bool32::default(),
24451             filter_minmax_image_component_mapping: Bool32::default(),
24452         }
24453     }
24454 }
24455 impl PhysicalDeviceSamplerFilterMinmaxProperties {
builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a>24456     pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
24457         PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder {
24458             inner: PhysicalDeviceSamplerFilterMinmaxProperties::default(),
24459             marker: ::std::marker::PhantomData,
24460         }
24461     }
24462 }
24463 #[repr(transparent)]
24464 pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
24465     inner: PhysicalDeviceSamplerFilterMinmaxProperties,
24466     marker: ::std::marker::PhantomData<&'a ()>,
24467 }
24468 unsafe impl ExtendsPhysicalDeviceProperties2
24469     for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_>
24470 {
24471 }
24472 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {}
24473 impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
24474     type Target = PhysicalDeviceSamplerFilterMinmaxProperties;
deref(&self) -> &Self::Target24475     fn deref(&self) -> &Self::Target {
24476         &self.inner
24477     }
24478 }
24479 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24480     fn deref_mut(&mut self) -> &mut Self::Target {
24481         &mut self.inner
24482     }
24483 }
24484 impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
filter_minmax_single_component_formats( mut self, filter_minmax_single_component_formats: bool, ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a>24485     pub fn filter_minmax_single_component_formats(
24486         mut self,
24487         filter_minmax_single_component_formats: bool,
24488     ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
24489         self.inner.filter_minmax_single_component_formats =
24490             filter_minmax_single_component_formats.into();
24491         self
24492     }
filter_minmax_image_component_mapping( mut self, filter_minmax_image_component_mapping: bool, ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a>24493     pub fn filter_minmax_image_component_mapping(
24494         mut self,
24495         filter_minmax_image_component_mapping: bool,
24496     ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
24497         self.inner.filter_minmax_image_component_mapping =
24498             filter_minmax_image_component_mapping.into();
24499         self
24500     }
24501     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24502     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24503     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties24504     pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties {
24505         self.inner
24506     }
24507 }
24508 #[repr(C)]
24509 #[derive(Copy, Clone, Default, Debug)]
24510 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleLocationEXT.html>"]
24511 pub struct SampleLocationEXT {
24512     pub x: f32,
24513     pub y: f32,
24514 }
24515 impl SampleLocationEXT {
builder<'a>() -> SampleLocationEXTBuilder<'a>24516     pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> {
24517         SampleLocationEXTBuilder {
24518             inner: SampleLocationEXT::default(),
24519             marker: ::std::marker::PhantomData,
24520         }
24521     }
24522 }
24523 #[repr(transparent)]
24524 pub struct SampleLocationEXTBuilder<'a> {
24525     inner: SampleLocationEXT,
24526     marker: ::std::marker::PhantomData<&'a ()>,
24527 }
24528 impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> {
24529     type Target = SampleLocationEXT;
deref(&self) -> &Self::Target24530     fn deref(&self) -> &Self::Target {
24531         &self.inner
24532     }
24533 }
24534 impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24535     fn deref_mut(&mut self) -> &mut Self::Target {
24536         &mut self.inner
24537     }
24538 }
24539 impl<'a> SampleLocationEXTBuilder<'a> {
x(mut self, x: f32) -> SampleLocationEXTBuilder<'a>24540     pub fn x(mut self, x: f32) -> SampleLocationEXTBuilder<'a> {
24541         self.inner.x = x;
24542         self
24543     }
y(mut self, y: f32) -> SampleLocationEXTBuilder<'a>24544     pub fn y(mut self, y: f32) -> SampleLocationEXTBuilder<'a> {
24545         self.inner.y = y;
24546         self
24547     }
24548     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24549     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24550     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SampleLocationEXT24551     pub fn build(self) -> SampleLocationEXT {
24552         self.inner
24553     }
24554 }
24555 #[repr(C)]
24556 #[derive(Copy, Clone, Debug)]
24557 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleLocationsInfoEXT.html>"]
24558 pub struct SampleLocationsInfoEXT {
24559     pub s_type: StructureType,
24560     pub p_next: *const c_void,
24561     pub sample_locations_per_pixel: SampleCountFlags,
24562     pub sample_location_grid_size: Extent2D,
24563     pub sample_locations_count: u32,
24564     pub p_sample_locations: *const SampleLocationEXT,
24565 }
24566 impl ::std::default::Default for SampleLocationsInfoEXT {
default() -> SampleLocationsInfoEXT24567     fn default() -> SampleLocationsInfoEXT {
24568         SampleLocationsInfoEXT {
24569             s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT,
24570             p_next: ::std::ptr::null(),
24571             sample_locations_per_pixel: SampleCountFlags::default(),
24572             sample_location_grid_size: Extent2D::default(),
24573             sample_locations_count: u32::default(),
24574             p_sample_locations: ::std::ptr::null(),
24575         }
24576     }
24577 }
24578 impl SampleLocationsInfoEXT {
builder<'a>() -> SampleLocationsInfoEXTBuilder<'a>24579     pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> {
24580         SampleLocationsInfoEXTBuilder {
24581             inner: SampleLocationsInfoEXT::default(),
24582             marker: ::std::marker::PhantomData,
24583         }
24584     }
24585 }
24586 #[repr(transparent)]
24587 pub struct SampleLocationsInfoEXTBuilder<'a> {
24588     inner: SampleLocationsInfoEXT,
24589     marker: ::std::marker::PhantomData<&'a ()>,
24590 }
24591 unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {}
24592 unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {}
24593 impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> {
24594     type Target = SampleLocationsInfoEXT;
deref(&self) -> &Self::Target24595     fn deref(&self) -> &Self::Target {
24596         &self.inner
24597     }
24598 }
24599 impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24600     fn deref_mut(&mut self) -> &mut Self::Target {
24601         &mut self.inner
24602     }
24603 }
24604 impl<'a> SampleLocationsInfoEXTBuilder<'a> {
sample_locations_per_pixel( mut self, sample_locations_per_pixel: SampleCountFlags, ) -> SampleLocationsInfoEXTBuilder<'a>24605     pub fn sample_locations_per_pixel(
24606         mut self,
24607         sample_locations_per_pixel: SampleCountFlags,
24608     ) -> SampleLocationsInfoEXTBuilder<'a> {
24609         self.inner.sample_locations_per_pixel = sample_locations_per_pixel;
24610         self
24611     }
sample_location_grid_size( mut self, sample_location_grid_size: Extent2D, ) -> SampleLocationsInfoEXTBuilder<'a>24612     pub fn sample_location_grid_size(
24613         mut self,
24614         sample_location_grid_size: Extent2D,
24615     ) -> SampleLocationsInfoEXTBuilder<'a> {
24616         self.inner.sample_location_grid_size = sample_location_grid_size;
24617         self
24618     }
sample_locations( mut self, sample_locations: &'a [SampleLocationEXT], ) -> SampleLocationsInfoEXTBuilder<'a>24619     pub fn sample_locations(
24620         mut self,
24621         sample_locations: &'a [SampleLocationEXT],
24622     ) -> SampleLocationsInfoEXTBuilder<'a> {
24623         self.inner.sample_locations_count = sample_locations.len() as _;
24624         self.inner.p_sample_locations = sample_locations.as_ptr();
24625         self
24626     }
24627     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24628     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24629     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SampleLocationsInfoEXT24630     pub fn build(self) -> SampleLocationsInfoEXT {
24631         self.inner
24632     }
24633 }
24634 #[repr(C)]
24635 #[derive(Copy, Clone, Default, Debug)]
24636 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentSampleLocationsEXT.html>"]
24637 pub struct AttachmentSampleLocationsEXT {
24638     pub attachment_index: u32,
24639     pub sample_locations_info: SampleLocationsInfoEXT,
24640 }
24641 impl AttachmentSampleLocationsEXT {
builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a>24642     pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> {
24643         AttachmentSampleLocationsEXTBuilder {
24644             inner: AttachmentSampleLocationsEXT::default(),
24645             marker: ::std::marker::PhantomData,
24646         }
24647     }
24648 }
24649 #[repr(transparent)]
24650 pub struct AttachmentSampleLocationsEXTBuilder<'a> {
24651     inner: AttachmentSampleLocationsEXT,
24652     marker: ::std::marker::PhantomData<&'a ()>,
24653 }
24654 impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> {
24655     type Target = AttachmentSampleLocationsEXT;
deref(&self) -> &Self::Target24656     fn deref(&self) -> &Self::Target {
24657         &self.inner
24658     }
24659 }
24660 impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24661     fn deref_mut(&mut self) -> &mut Self::Target {
24662         &mut self.inner
24663     }
24664 }
24665 impl<'a> AttachmentSampleLocationsEXTBuilder<'a> {
attachment_index( mut self, attachment_index: u32, ) -> AttachmentSampleLocationsEXTBuilder<'a>24666     pub fn attachment_index(
24667         mut self,
24668         attachment_index: u32,
24669     ) -> AttachmentSampleLocationsEXTBuilder<'a> {
24670         self.inner.attachment_index = attachment_index;
24671         self
24672     }
sample_locations_info( mut self, sample_locations_info: SampleLocationsInfoEXT, ) -> AttachmentSampleLocationsEXTBuilder<'a>24673     pub fn sample_locations_info(
24674         mut self,
24675         sample_locations_info: SampleLocationsInfoEXT,
24676     ) -> AttachmentSampleLocationsEXTBuilder<'a> {
24677         self.inner.sample_locations_info = sample_locations_info;
24678         self
24679     }
24680     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24681     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24682     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentSampleLocationsEXT24683     pub fn build(self) -> AttachmentSampleLocationsEXT {
24684         self.inner
24685     }
24686 }
24687 #[repr(C)]
24688 #[derive(Copy, Clone, Default, Debug)]
24689 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassSampleLocationsEXT.html>"]
24690 pub struct SubpassSampleLocationsEXT {
24691     pub subpass_index: u32,
24692     pub sample_locations_info: SampleLocationsInfoEXT,
24693 }
24694 impl SubpassSampleLocationsEXT {
builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a>24695     pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> {
24696         SubpassSampleLocationsEXTBuilder {
24697             inner: SubpassSampleLocationsEXT::default(),
24698             marker: ::std::marker::PhantomData,
24699         }
24700     }
24701 }
24702 #[repr(transparent)]
24703 pub struct SubpassSampleLocationsEXTBuilder<'a> {
24704     inner: SubpassSampleLocationsEXT,
24705     marker: ::std::marker::PhantomData<&'a ()>,
24706 }
24707 impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> {
24708     type Target = SubpassSampleLocationsEXT;
deref(&self) -> &Self::Target24709     fn deref(&self) -> &Self::Target {
24710         &self.inner
24711     }
24712 }
24713 impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24714     fn deref_mut(&mut self) -> &mut Self::Target {
24715         &mut self.inner
24716     }
24717 }
24718 impl<'a> SubpassSampleLocationsEXTBuilder<'a> {
subpass_index(mut self, subpass_index: u32) -> SubpassSampleLocationsEXTBuilder<'a>24719     pub fn subpass_index(mut self, subpass_index: u32) -> SubpassSampleLocationsEXTBuilder<'a> {
24720         self.inner.subpass_index = subpass_index;
24721         self
24722     }
sample_locations_info( mut self, sample_locations_info: SampleLocationsInfoEXT, ) -> SubpassSampleLocationsEXTBuilder<'a>24723     pub fn sample_locations_info(
24724         mut self,
24725         sample_locations_info: SampleLocationsInfoEXT,
24726     ) -> SubpassSampleLocationsEXTBuilder<'a> {
24727         self.inner.sample_locations_info = sample_locations_info;
24728         self
24729     }
24730     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24731     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24732     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassSampleLocationsEXT24733     pub fn build(self) -> SubpassSampleLocationsEXT {
24734         self.inner
24735     }
24736 }
24737 #[repr(C)]
24738 #[derive(Copy, Clone, Debug)]
24739 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>"]
24740 pub struct RenderPassSampleLocationsBeginInfoEXT {
24741     pub s_type: StructureType,
24742     pub p_next: *const c_void,
24743     pub attachment_initial_sample_locations_count: u32,
24744     pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT,
24745     pub post_subpass_sample_locations_count: u32,
24746     pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT,
24747 }
24748 impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT {
default() -> RenderPassSampleLocationsBeginInfoEXT24749     fn default() -> RenderPassSampleLocationsBeginInfoEXT {
24750         RenderPassSampleLocationsBeginInfoEXT {
24751             s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
24752             p_next: ::std::ptr::null(),
24753             attachment_initial_sample_locations_count: u32::default(),
24754             p_attachment_initial_sample_locations: ::std::ptr::null(),
24755             post_subpass_sample_locations_count: u32::default(),
24756             p_post_subpass_sample_locations: ::std::ptr::null(),
24757         }
24758     }
24759 }
24760 impl RenderPassSampleLocationsBeginInfoEXT {
builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a>24761     pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
24762         RenderPassSampleLocationsBeginInfoEXTBuilder {
24763             inner: RenderPassSampleLocationsBeginInfoEXT::default(),
24764             marker: ::std::marker::PhantomData,
24765         }
24766     }
24767 }
24768 #[repr(transparent)]
24769 pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
24770     inner: RenderPassSampleLocationsBeginInfoEXT,
24771     marker: ::std::marker::PhantomData<&'a ()>,
24772 }
24773 unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {}
24774 unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {}
24775 impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
24776     type Target = RenderPassSampleLocationsBeginInfoEXT;
deref(&self) -> &Self::Target24777     fn deref(&self) -> &Self::Target {
24778         &self.inner
24779     }
24780 }
24781 impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24782     fn deref_mut(&mut self) -> &mut Self::Target {
24783         &mut self.inner
24784     }
24785 }
24786 impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
attachment_initial_sample_locations( mut self, attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT], ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a>24787     pub fn attachment_initial_sample_locations(
24788         mut self,
24789         attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT],
24790     ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
24791         self.inner.attachment_initial_sample_locations_count =
24792             attachment_initial_sample_locations.len() as _;
24793         self.inner.p_attachment_initial_sample_locations =
24794             attachment_initial_sample_locations.as_ptr();
24795         self
24796     }
post_subpass_sample_locations( mut self, post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT], ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a>24797     pub fn post_subpass_sample_locations(
24798         mut self,
24799         post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT],
24800     ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
24801         self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _;
24802         self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr();
24803         self
24804     }
24805     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24806     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24807     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassSampleLocationsBeginInfoEXT24808     pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT {
24809         self.inner
24810     }
24811 }
24812 #[repr(C)]
24813 #[derive(Copy, Clone, Debug)]
24814 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>"]
24815 pub struct PipelineSampleLocationsStateCreateInfoEXT {
24816     pub s_type: StructureType,
24817     pub p_next: *const c_void,
24818     pub sample_locations_enable: Bool32,
24819     pub sample_locations_info: SampleLocationsInfoEXT,
24820 }
24821 impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT {
default() -> PipelineSampleLocationsStateCreateInfoEXT24822     fn default() -> PipelineSampleLocationsStateCreateInfoEXT {
24823         PipelineSampleLocationsStateCreateInfoEXT {
24824             s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
24825             p_next: ::std::ptr::null(),
24826             sample_locations_enable: Bool32::default(),
24827             sample_locations_info: SampleLocationsInfoEXT::default(),
24828         }
24829     }
24830 }
24831 impl PipelineSampleLocationsStateCreateInfoEXT {
builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a>24832     pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
24833         PipelineSampleLocationsStateCreateInfoEXTBuilder {
24834             inner: PipelineSampleLocationsStateCreateInfoEXT::default(),
24835             marker: ::std::marker::PhantomData,
24836         }
24837     }
24838 }
24839 #[repr(transparent)]
24840 pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
24841     inner: PipelineSampleLocationsStateCreateInfoEXT,
24842     marker: ::std::marker::PhantomData<&'a ()>,
24843 }
24844 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
24845     for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_>
24846 {
24847 }
24848 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
24849     for PipelineSampleLocationsStateCreateInfoEXT
24850 {
24851 }
24852 impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
24853     type Target = PipelineSampleLocationsStateCreateInfoEXT;
deref(&self) -> &Self::Target24854     fn deref(&self) -> &Self::Target {
24855         &self.inner
24856     }
24857 }
24858 impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24859     fn deref_mut(&mut self) -> &mut Self::Target {
24860         &mut self.inner
24861     }
24862 }
24863 impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
sample_locations_enable( mut self, sample_locations_enable: bool, ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a>24864     pub fn sample_locations_enable(
24865         mut self,
24866         sample_locations_enable: bool,
24867     ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
24868         self.inner.sample_locations_enable = sample_locations_enable.into();
24869         self
24870     }
sample_locations_info( mut self, sample_locations_info: SampleLocationsInfoEXT, ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a>24871     pub fn sample_locations_info(
24872         mut self,
24873         sample_locations_info: SampleLocationsInfoEXT,
24874     ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
24875         self.inner.sample_locations_info = sample_locations_info;
24876         self
24877     }
24878     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24879     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24880     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineSampleLocationsStateCreateInfoEXT24881     pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT {
24882         self.inner
24883     }
24884 }
24885 #[repr(C)]
24886 #[derive(Copy, Clone, Debug)]
24887 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>"]
24888 pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
24889     pub s_type: StructureType,
24890     pub p_next: *mut c_void,
24891     pub sample_location_sample_counts: SampleCountFlags,
24892     pub max_sample_location_grid_size: Extent2D,
24893     pub sample_location_coordinate_range: [f32; 2],
24894     pub sample_location_sub_pixel_bits: u32,
24895     pub variable_sample_locations: Bool32,
24896 }
24897 impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT {
default() -> PhysicalDeviceSampleLocationsPropertiesEXT24898     fn default() -> PhysicalDeviceSampleLocationsPropertiesEXT {
24899         PhysicalDeviceSampleLocationsPropertiesEXT {
24900             s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
24901             p_next: ::std::ptr::null_mut(),
24902             sample_location_sample_counts: SampleCountFlags::default(),
24903             max_sample_location_grid_size: Extent2D::default(),
24904             sample_location_coordinate_range: unsafe { ::std::mem::zeroed() },
24905             sample_location_sub_pixel_bits: u32::default(),
24906             variable_sample_locations: Bool32::default(),
24907         }
24908     }
24909 }
24910 impl PhysicalDeviceSampleLocationsPropertiesEXT {
builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a>24911     pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24912         PhysicalDeviceSampleLocationsPropertiesEXTBuilder {
24913             inner: PhysicalDeviceSampleLocationsPropertiesEXT::default(),
24914             marker: ::std::marker::PhantomData,
24915         }
24916     }
24917 }
24918 #[repr(transparent)]
24919 pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24920     inner: PhysicalDeviceSampleLocationsPropertiesEXT,
24921     marker: ::std::marker::PhantomData<&'a ()>,
24922 }
24923 unsafe impl ExtendsPhysicalDeviceProperties2
24924     for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_>
24925 {
24926 }
24927 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {}
24928 impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24929     type Target = PhysicalDeviceSampleLocationsPropertiesEXT;
deref(&self) -> &Self::Target24930     fn deref(&self) -> &Self::Target {
24931         &self.inner
24932     }
24933 }
24934 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target24935     fn deref_mut(&mut self) -> &mut Self::Target {
24936         &mut self.inner
24937     }
24938 }
24939 impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
sample_location_sample_counts( mut self, sample_location_sample_counts: SampleCountFlags, ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a>24940     pub fn sample_location_sample_counts(
24941         mut self,
24942         sample_location_sample_counts: SampleCountFlags,
24943     ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24944         self.inner.sample_location_sample_counts = sample_location_sample_counts;
24945         self
24946     }
max_sample_location_grid_size( mut self, max_sample_location_grid_size: Extent2D, ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a>24947     pub fn max_sample_location_grid_size(
24948         mut self,
24949         max_sample_location_grid_size: Extent2D,
24950     ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24951         self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
24952         self
24953     }
sample_location_coordinate_range( mut self, sample_location_coordinate_range: [f32; 2], ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a>24954     pub fn sample_location_coordinate_range(
24955         mut self,
24956         sample_location_coordinate_range: [f32; 2],
24957     ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24958         self.inner.sample_location_coordinate_range = sample_location_coordinate_range;
24959         self
24960     }
sample_location_sub_pixel_bits( mut self, sample_location_sub_pixel_bits: u32, ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a>24961     pub fn sample_location_sub_pixel_bits(
24962         mut self,
24963         sample_location_sub_pixel_bits: u32,
24964     ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24965         self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits;
24966         self
24967     }
variable_sample_locations( mut self, variable_sample_locations: bool, ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a>24968     pub fn variable_sample_locations(
24969         mut self,
24970         variable_sample_locations: bool,
24971     ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
24972         self.inner.variable_sample_locations = variable_sample_locations.into();
24973         self
24974     }
24975     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
24976     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
24977     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT24978     pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT {
24979         self.inner
24980     }
24981 }
24982 #[repr(C)]
24983 #[derive(Copy, Clone, Debug)]
24984 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMultisamplePropertiesEXT.html>"]
24985 pub struct MultisamplePropertiesEXT {
24986     pub s_type: StructureType,
24987     pub p_next: *mut c_void,
24988     pub max_sample_location_grid_size: Extent2D,
24989 }
24990 impl ::std::default::Default for MultisamplePropertiesEXT {
default() -> MultisamplePropertiesEXT24991     fn default() -> MultisamplePropertiesEXT {
24992         MultisamplePropertiesEXT {
24993             s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT,
24994             p_next: ::std::ptr::null_mut(),
24995             max_sample_location_grid_size: Extent2D::default(),
24996         }
24997     }
24998 }
24999 impl MultisamplePropertiesEXT {
builder<'a>() -> MultisamplePropertiesEXTBuilder<'a>25000     pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> {
25001         MultisamplePropertiesEXTBuilder {
25002             inner: MultisamplePropertiesEXT::default(),
25003             marker: ::std::marker::PhantomData,
25004         }
25005     }
25006 }
25007 #[repr(transparent)]
25008 pub struct MultisamplePropertiesEXTBuilder<'a> {
25009     inner: MultisamplePropertiesEXT,
25010     marker: ::std::marker::PhantomData<&'a ()>,
25011 }
25012 pub unsafe trait ExtendsMultisamplePropertiesEXT {}
25013 impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> {
25014     type Target = MultisamplePropertiesEXT;
deref(&self) -> &Self::Target25015     fn deref(&self) -> &Self::Target {
25016         &self.inner
25017     }
25018 }
25019 impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25020     fn deref_mut(&mut self) -> &mut Self::Target {
25021         &mut self.inner
25022     }
25023 }
25024 impl<'a> MultisamplePropertiesEXTBuilder<'a> {
max_sample_location_grid_size( mut self, max_sample_location_grid_size: Extent2D, ) -> MultisamplePropertiesEXTBuilder<'a>25025     pub fn max_sample_location_grid_size(
25026         mut self,
25027         max_sample_location_grid_size: Extent2D,
25028     ) -> MultisamplePropertiesEXTBuilder<'a> {
25029         self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
25030         self
25031     }
25032     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
25033     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
25034     #[doc = r" valid extension structs can be pushed into the chain."]
25035     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
25036     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMultisamplePropertiesEXT>( mut self, next: &'a mut T, ) -> MultisamplePropertiesEXTBuilder<'a>25037     pub fn push_next<T: ExtendsMultisamplePropertiesEXT>(
25038         mut self,
25039         next: &'a mut T,
25040     ) -> MultisamplePropertiesEXTBuilder<'a> {
25041         unsafe {
25042             let next_ptr = next as *mut T as *mut BaseOutStructure;
25043             let last_next = ptr_chain_iter(next).last().unwrap();
25044             (*last_next).p_next = self.inner.p_next as _;
25045             self.inner.p_next = next_ptr as _;
25046         }
25047         self
25048     }
25049     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25050     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25051     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MultisamplePropertiesEXT25052     pub fn build(self) -> MultisamplePropertiesEXT {
25053         self.inner
25054     }
25055 }
25056 #[repr(C)]
25057 #[derive(Copy, Clone, Debug)]
25058 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerReductionModeCreateInfo.html>"]
25059 pub struct SamplerReductionModeCreateInfo {
25060     pub s_type: StructureType,
25061     pub p_next: *const c_void,
25062     pub reduction_mode: SamplerReductionMode,
25063 }
25064 impl ::std::default::Default for SamplerReductionModeCreateInfo {
default() -> SamplerReductionModeCreateInfo25065     fn default() -> SamplerReductionModeCreateInfo {
25066         SamplerReductionModeCreateInfo {
25067             s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO,
25068             p_next: ::std::ptr::null(),
25069             reduction_mode: SamplerReductionMode::default(),
25070         }
25071     }
25072 }
25073 impl SamplerReductionModeCreateInfo {
builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a>25074     pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> {
25075         SamplerReductionModeCreateInfoBuilder {
25076             inner: SamplerReductionModeCreateInfo::default(),
25077             marker: ::std::marker::PhantomData,
25078         }
25079     }
25080 }
25081 #[repr(transparent)]
25082 pub struct SamplerReductionModeCreateInfoBuilder<'a> {
25083     inner: SamplerReductionModeCreateInfo,
25084     marker: ::std::marker::PhantomData<&'a ()>,
25085 }
25086 unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {}
25087 unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {}
25088 impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> {
25089     type Target = SamplerReductionModeCreateInfo;
deref(&self) -> &Self::Target25090     fn deref(&self) -> &Self::Target {
25091         &self.inner
25092     }
25093 }
25094 impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25095     fn deref_mut(&mut self) -> &mut Self::Target {
25096         &mut self.inner
25097     }
25098 }
25099 impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
reduction_mode( mut self, reduction_mode: SamplerReductionMode, ) -> SamplerReductionModeCreateInfoBuilder<'a>25100     pub fn reduction_mode(
25101         mut self,
25102         reduction_mode: SamplerReductionMode,
25103     ) -> SamplerReductionModeCreateInfoBuilder<'a> {
25104         self.inner.reduction_mode = reduction_mode;
25105         self
25106     }
25107     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25108     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25109     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerReductionModeCreateInfo25110     pub fn build(self) -> SamplerReductionModeCreateInfo {
25111         self.inner
25112     }
25113 }
25114 #[repr(C)]
25115 #[derive(Copy, Clone, Debug)]
25116 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>"]
25117 pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25118     pub s_type: StructureType,
25119     pub p_next: *mut c_void,
25120     pub advanced_blend_coherent_operations: Bool32,
25121 }
25122 impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
default() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT25123     fn default() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25124         PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25125             s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
25126             p_next: ::std::ptr::null_mut(),
25127             advanced_blend_coherent_operations: Bool32::default(),
25128         }
25129     }
25130 }
25131 impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a>25132     pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25133         PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder {
25134             inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT::default(),
25135             marker: ::std::marker::PhantomData,
25136         }
25137     }
25138 }
25139 #[repr(transparent)]
25140 pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25141     inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
25142     marker: ::std::marker::PhantomData<&'a ()>,
25143 }
25144 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {}
25145 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
25146 impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25147     type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
deref(&self) -> &Self::Target25148     fn deref(&self) -> &Self::Target {
25149         &self.inner
25150     }
25151 }
25152 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25153     fn deref_mut(&mut self) -> &mut Self::Target {
25154         &mut self.inner
25155     }
25156 }
25157 impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
advanced_blend_coherent_operations( mut self, advanced_blend_coherent_operations: bool, ) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a>25158     pub fn advanced_blend_coherent_operations(
25159         mut self,
25160         advanced_blend_coherent_operations: bool,
25161     ) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
25162         self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into();
25163         self
25164     }
25165     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25166     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25167     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT25168     pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
25169         self.inner
25170     }
25171 }
25172 #[repr(C)]
25173 #[derive(Copy, Clone, Debug)]
25174 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>"]
25175 pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25176     pub s_type: StructureType,
25177     pub p_next: *mut c_void,
25178     pub advanced_blend_max_color_attachments: u32,
25179     pub advanced_blend_independent_blend: Bool32,
25180     pub advanced_blend_non_premultiplied_src_color: Bool32,
25181     pub advanced_blend_non_premultiplied_dst_color: Bool32,
25182     pub advanced_blend_correlated_overlap: Bool32,
25183     pub advanced_blend_all_operations: Bool32,
25184 }
25185 impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
default() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT25186     fn default() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25187         PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25188             s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
25189             p_next: ::std::ptr::null_mut(),
25190             advanced_blend_max_color_attachments: u32::default(),
25191             advanced_blend_independent_blend: Bool32::default(),
25192             advanced_blend_non_premultiplied_src_color: Bool32::default(),
25193             advanced_blend_non_premultiplied_dst_color: Bool32::default(),
25194             advanced_blend_correlated_overlap: Bool32::default(),
25195             advanced_blend_all_operations: Bool32::default(),
25196         }
25197     }
25198 }
25199 impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25200     pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25201         PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder {
25202             inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT::default(),
25203             marker: ::std::marker::PhantomData,
25204         }
25205     }
25206 }
25207 #[repr(transparent)]
25208 pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25209     inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
25210     marker: ::std::marker::PhantomData<&'a ()>,
25211 }
25212 unsafe impl ExtendsPhysicalDeviceProperties2
25213     for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_>
25214 {
25215 }
25216 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {}
25217 impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25218     type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
deref(&self) -> &Self::Target25219     fn deref(&self) -> &Self::Target {
25220         &self.inner
25221     }
25222 }
25223 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25224     fn deref_mut(&mut self) -> &mut Self::Target {
25225         &mut self.inner
25226     }
25227 }
25228 impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
advanced_blend_max_color_attachments( mut self, advanced_blend_max_color_attachments: u32, ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25229     pub fn advanced_blend_max_color_attachments(
25230         mut self,
25231         advanced_blend_max_color_attachments: u32,
25232     ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25233         self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments;
25234         self
25235     }
advanced_blend_independent_blend( mut self, advanced_blend_independent_blend: bool, ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25236     pub fn advanced_blend_independent_blend(
25237         mut self,
25238         advanced_blend_independent_blend: bool,
25239     ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25240         self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into();
25241         self
25242     }
advanced_blend_non_premultiplied_src_color( mut self, advanced_blend_non_premultiplied_src_color: bool, ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25243     pub fn advanced_blend_non_premultiplied_src_color(
25244         mut self,
25245         advanced_blend_non_premultiplied_src_color: bool,
25246     ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25247         self.inner.advanced_blend_non_premultiplied_src_color =
25248             advanced_blend_non_premultiplied_src_color.into();
25249         self
25250     }
advanced_blend_non_premultiplied_dst_color( mut self, advanced_blend_non_premultiplied_dst_color: bool, ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25251     pub fn advanced_blend_non_premultiplied_dst_color(
25252         mut self,
25253         advanced_blend_non_premultiplied_dst_color: bool,
25254     ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25255         self.inner.advanced_blend_non_premultiplied_dst_color =
25256             advanced_blend_non_premultiplied_dst_color.into();
25257         self
25258     }
advanced_blend_correlated_overlap( mut self, advanced_blend_correlated_overlap: bool, ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25259     pub fn advanced_blend_correlated_overlap(
25260         mut self,
25261         advanced_blend_correlated_overlap: bool,
25262     ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25263         self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into();
25264         self
25265     }
advanced_blend_all_operations( mut self, advanced_blend_all_operations: bool, ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a>25266     pub fn advanced_blend_all_operations(
25267         mut self,
25268         advanced_blend_all_operations: bool,
25269     ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
25270         self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into();
25271         self
25272     }
25273     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25274     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25275     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT25276     pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
25277         self.inner
25278     }
25279 }
25280 #[repr(C)]
25281 #[derive(Copy, Clone, Debug)]
25282 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>"]
25283 pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
25284     pub s_type: StructureType,
25285     pub p_next: *const c_void,
25286     pub src_premultiplied: Bool32,
25287     pub dst_premultiplied: Bool32,
25288     pub blend_overlap: BlendOverlapEXT,
25289 }
25290 impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
default() -> PipelineColorBlendAdvancedStateCreateInfoEXT25291     fn default() -> PipelineColorBlendAdvancedStateCreateInfoEXT {
25292         PipelineColorBlendAdvancedStateCreateInfoEXT {
25293             s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
25294             p_next: ::std::ptr::null(),
25295             src_premultiplied: Bool32::default(),
25296             dst_premultiplied: Bool32::default(),
25297             blend_overlap: BlendOverlapEXT::default(),
25298         }
25299     }
25300 }
25301 impl PipelineColorBlendAdvancedStateCreateInfoEXT {
builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a>25302     pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25303         PipelineColorBlendAdvancedStateCreateInfoEXTBuilder {
25304             inner: PipelineColorBlendAdvancedStateCreateInfoEXT::default(),
25305             marker: ::std::marker::PhantomData,
25306         }
25307     }
25308 }
25309 #[repr(transparent)]
25310 pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25311     inner: PipelineColorBlendAdvancedStateCreateInfoEXT,
25312     marker: ::std::marker::PhantomData<&'a ()>,
25313 }
25314 unsafe impl ExtendsPipelineColorBlendStateCreateInfo
25315     for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_>
25316 {
25317 }
25318 unsafe impl ExtendsPipelineColorBlendStateCreateInfo
25319     for PipelineColorBlendAdvancedStateCreateInfoEXT
25320 {
25321 }
25322 impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25323     type Target = PipelineColorBlendAdvancedStateCreateInfoEXT;
deref(&self) -> &Self::Target25324     fn deref(&self) -> &Self::Target {
25325         &self.inner
25326     }
25327 }
25328 impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25329     fn deref_mut(&mut self) -> &mut Self::Target {
25330         &mut self.inner
25331     }
25332 }
25333 impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
src_premultiplied( mut self, src_premultiplied: bool, ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a>25334     pub fn src_premultiplied(
25335         mut self,
25336         src_premultiplied: bool,
25337     ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25338         self.inner.src_premultiplied = src_premultiplied.into();
25339         self
25340     }
dst_premultiplied( mut self, dst_premultiplied: bool, ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a>25341     pub fn dst_premultiplied(
25342         mut self,
25343         dst_premultiplied: bool,
25344     ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25345         self.inner.dst_premultiplied = dst_premultiplied.into();
25346         self
25347     }
blend_overlap( mut self, blend_overlap: BlendOverlapEXT, ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a>25348     pub fn blend_overlap(
25349         mut self,
25350         blend_overlap: BlendOverlapEXT,
25351     ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
25352         self.inner.blend_overlap = blend_overlap;
25353         self
25354     }
25355     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25356     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25357     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT25358     pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT {
25359         self.inner
25360     }
25361 }
25362 #[repr(C)]
25363 #[derive(Copy, Clone, Debug)]
25364 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.html>"]
25365 pub struct PhysicalDeviceInlineUniformBlockFeaturesEXT {
25366     pub s_type: StructureType,
25367     pub p_next: *mut c_void,
25368     pub inline_uniform_block: Bool32,
25369     pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
25370 }
25371 impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeaturesEXT {
default() -> PhysicalDeviceInlineUniformBlockFeaturesEXT25372     fn default() -> PhysicalDeviceInlineUniformBlockFeaturesEXT {
25373         PhysicalDeviceInlineUniformBlockFeaturesEXT {
25374             s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT,
25375             p_next: ::std::ptr::null_mut(),
25376             inline_uniform_block: Bool32::default(),
25377             descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
25378         }
25379     }
25380 }
25381 impl PhysicalDeviceInlineUniformBlockFeaturesEXT {
builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a>25382     pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
25383         PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder {
25384             inner: PhysicalDeviceInlineUniformBlockFeaturesEXT::default(),
25385             marker: ::std::marker::PhantomData,
25386         }
25387     }
25388 }
25389 #[repr(transparent)]
25390 pub struct PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
25391     inner: PhysicalDeviceInlineUniformBlockFeaturesEXT,
25392     marker: ::std::marker::PhantomData<&'a ()>,
25393 }
25394 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> {}
25395 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT {}
25396 impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
25397     type Target = PhysicalDeviceInlineUniformBlockFeaturesEXT;
deref(&self) -> &Self::Target25398     fn deref(&self) -> &Self::Target {
25399         &self.inner
25400     }
25401 }
25402 impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25403     fn deref_mut(&mut self) -> &mut Self::Target {
25404         &mut self.inner
25405     }
25406 }
25407 impl<'a> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
inline_uniform_block( mut self, inline_uniform_block: bool, ) -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a>25408     pub fn inline_uniform_block(
25409         mut self,
25410         inline_uniform_block: bool,
25411     ) -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
25412         self.inner.inline_uniform_block = inline_uniform_block.into();
25413         self
25414     }
descriptor_binding_inline_uniform_block_update_after_bind( mut self, descriptor_binding_inline_uniform_block_update_after_bind: bool, ) -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a>25415     pub fn descriptor_binding_inline_uniform_block_update_after_bind(
25416         mut self,
25417         descriptor_binding_inline_uniform_block_update_after_bind: bool,
25418     ) -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
25419         self.inner
25420             .descriptor_binding_inline_uniform_block_update_after_bind =
25421             descriptor_binding_inline_uniform_block_update_after_bind.into();
25422         self
25423     }
25424     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25425     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25426     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceInlineUniformBlockFeaturesEXT25427     pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeaturesEXT {
25428         self.inner
25429     }
25430 }
25431 #[repr(C)]
25432 #[derive(Copy, Clone, Debug)]
25433 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html>"]
25434 pub struct PhysicalDeviceInlineUniformBlockPropertiesEXT {
25435     pub s_type: StructureType,
25436     pub p_next: *mut c_void,
25437     pub max_inline_uniform_block_size: u32,
25438     pub max_per_stage_descriptor_inline_uniform_blocks: u32,
25439     pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
25440     pub max_descriptor_set_inline_uniform_blocks: u32,
25441     pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
25442 }
25443 impl ::std::default::Default for PhysicalDeviceInlineUniformBlockPropertiesEXT {
default() -> PhysicalDeviceInlineUniformBlockPropertiesEXT25444     fn default() -> PhysicalDeviceInlineUniformBlockPropertiesEXT {
25445         PhysicalDeviceInlineUniformBlockPropertiesEXT {
25446             s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT,
25447             p_next: ::std::ptr::null_mut(),
25448             max_inline_uniform_block_size: u32::default(),
25449             max_per_stage_descriptor_inline_uniform_blocks: u32::default(),
25450             max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(),
25451             max_descriptor_set_inline_uniform_blocks: u32::default(),
25452             max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(),
25453         }
25454     }
25455 }
25456 impl PhysicalDeviceInlineUniformBlockPropertiesEXT {
builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a>25457     pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25458         PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder {
25459             inner: PhysicalDeviceInlineUniformBlockPropertiesEXT::default(),
25460             marker: ::std::marker::PhantomData,
25461         }
25462     }
25463 }
25464 #[repr(transparent)]
25465 pub struct PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25466     inner: PhysicalDeviceInlineUniformBlockPropertiesEXT,
25467     marker: ::std::marker::PhantomData<&'a ()>,
25468 }
25469 unsafe impl ExtendsPhysicalDeviceProperties2
25470     for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'_>
25471 {
25472 }
25473 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXT {}
25474 impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25475     type Target = PhysicalDeviceInlineUniformBlockPropertiesEXT;
deref(&self) -> &Self::Target25476     fn deref(&self) -> &Self::Target {
25477         &self.inner
25478     }
25479 }
25480 impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25481     fn deref_mut(&mut self) -> &mut Self::Target {
25482         &mut self.inner
25483     }
25484 }
25485 impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
max_inline_uniform_block_size( mut self, max_inline_uniform_block_size: u32, ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a>25486     pub fn max_inline_uniform_block_size(
25487         mut self,
25488         max_inline_uniform_block_size: u32,
25489     ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25490         self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
25491         self
25492     }
max_per_stage_descriptor_inline_uniform_blocks( mut self, max_per_stage_descriptor_inline_uniform_blocks: u32, ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a>25493     pub fn max_per_stage_descriptor_inline_uniform_blocks(
25494         mut self,
25495         max_per_stage_descriptor_inline_uniform_blocks: u32,
25496     ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25497         self.inner.max_per_stage_descriptor_inline_uniform_blocks =
25498             max_per_stage_descriptor_inline_uniform_blocks;
25499         self
25500     }
max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( mut self, max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a>25501     pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
25502         mut self,
25503         max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
25504     ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25505         self.inner
25506             .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
25507             max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
25508         self
25509     }
max_descriptor_set_inline_uniform_blocks( mut self, max_descriptor_set_inline_uniform_blocks: u32, ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a>25510     pub fn max_descriptor_set_inline_uniform_blocks(
25511         mut self,
25512         max_descriptor_set_inline_uniform_blocks: u32,
25513     ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25514         self.inner.max_descriptor_set_inline_uniform_blocks =
25515             max_descriptor_set_inline_uniform_blocks;
25516         self
25517     }
max_descriptor_set_update_after_bind_inline_uniform_blocks( mut self, max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a>25518     pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
25519         mut self,
25520         max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
25521     ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
25522         self.inner
25523             .max_descriptor_set_update_after_bind_inline_uniform_blocks =
25524             max_descriptor_set_update_after_bind_inline_uniform_blocks;
25525         self
25526     }
25527     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25528     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25529     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceInlineUniformBlockPropertiesEXT25530     pub fn build(self) -> PhysicalDeviceInlineUniformBlockPropertiesEXT {
25531         self.inner
25532     }
25533 }
25534 #[repr(C)]
25535 #[derive(Copy, Clone, Debug)]
25536 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetInlineUniformBlockEXT.html>"]
25537 pub struct WriteDescriptorSetInlineUniformBlockEXT {
25538     pub s_type: StructureType,
25539     pub p_next: *const c_void,
25540     pub data_size: u32,
25541     pub p_data: *const c_void,
25542 }
25543 impl ::std::default::Default for WriteDescriptorSetInlineUniformBlockEXT {
default() -> WriteDescriptorSetInlineUniformBlockEXT25544     fn default() -> WriteDescriptorSetInlineUniformBlockEXT {
25545         WriteDescriptorSetInlineUniformBlockEXT {
25546             s_type: StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT,
25547             p_next: ::std::ptr::null(),
25548             data_size: u32::default(),
25549             p_data: ::std::ptr::null(),
25550         }
25551     }
25552 }
25553 impl WriteDescriptorSetInlineUniformBlockEXT {
builder<'a>() -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a>25554     pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
25555         WriteDescriptorSetInlineUniformBlockEXTBuilder {
25556             inner: WriteDescriptorSetInlineUniformBlockEXT::default(),
25557             marker: ::std::marker::PhantomData,
25558         }
25559     }
25560 }
25561 #[repr(transparent)]
25562 pub struct WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
25563     inner: WriteDescriptorSetInlineUniformBlockEXT,
25564     marker: ::std::marker::PhantomData<&'a ()>,
25565 }
25566 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXTBuilder<'_> {}
25567 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXT {}
25568 impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
25569     type Target = WriteDescriptorSetInlineUniformBlockEXT;
deref(&self) -> &Self::Target25570     fn deref(&self) -> &Self::Target {
25571         &self.inner
25572     }
25573 }
25574 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25575     fn deref_mut(&mut self) -> &mut Self::Target {
25576         &mut self.inner
25577     }
25578 }
25579 impl<'a> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
data(mut self, data: &'a [u8]) -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a>25580     pub fn data(mut self, data: &'a [u8]) -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
25581         self.inner.data_size = data.len() as _;
25582         self.inner.p_data = data.as_ptr() as *const c_void;
25583         self
25584     }
25585     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25586     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25587     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSetInlineUniformBlockEXT25588     pub fn build(self) -> WriteDescriptorSetInlineUniformBlockEXT {
25589         self.inner
25590     }
25591 }
25592 #[repr(C)]
25593 #[derive(Copy, Clone, Debug)]
25594 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfoEXT.html>"]
25595 pub struct DescriptorPoolInlineUniformBlockCreateInfoEXT {
25596     pub s_type: StructureType,
25597     pub p_next: *const c_void,
25598     pub max_inline_uniform_block_bindings: u32,
25599 }
25600 impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfoEXT {
default() -> DescriptorPoolInlineUniformBlockCreateInfoEXT25601     fn default() -> DescriptorPoolInlineUniformBlockCreateInfoEXT {
25602         DescriptorPoolInlineUniformBlockCreateInfoEXT {
25603             s_type: StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT,
25604             p_next: ::std::ptr::null(),
25605             max_inline_uniform_block_bindings: u32::default(),
25606         }
25607     }
25608 }
25609 impl DescriptorPoolInlineUniformBlockCreateInfoEXT {
builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a>25610     pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
25611         DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder {
25612             inner: DescriptorPoolInlineUniformBlockCreateInfoEXT::default(),
25613             marker: ::std::marker::PhantomData,
25614         }
25615     }
25616 }
25617 #[repr(transparent)]
25618 pub struct DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
25619     inner: DescriptorPoolInlineUniformBlockCreateInfoEXT,
25620     marker: ::std::marker::PhantomData<&'a ()>,
25621 }
25622 unsafe impl ExtendsDescriptorPoolCreateInfo
25623     for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'_>
25624 {
25625 }
25626 unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXT {}
25627 impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
25628     type Target = DescriptorPoolInlineUniformBlockCreateInfoEXT;
deref(&self) -> &Self::Target25629     fn deref(&self) -> &Self::Target {
25630         &self.inner
25631     }
25632 }
25633 impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25634     fn deref_mut(&mut self) -> &mut Self::Target {
25635         &mut self.inner
25636     }
25637 }
25638 impl<'a> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
max_inline_uniform_block_bindings( mut self, max_inline_uniform_block_bindings: u32, ) -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a>25639     pub fn max_inline_uniform_block_bindings(
25640         mut self,
25641         max_inline_uniform_block_bindings: u32,
25642     ) -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
25643         self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings;
25644         self
25645     }
25646     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25647     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25648     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorPoolInlineUniformBlockCreateInfoEXT25649     pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfoEXT {
25650         self.inner
25651     }
25652 }
25653 #[repr(C)]
25654 #[derive(Copy, Clone, Debug)]
25655 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>"]
25656 pub struct PipelineCoverageModulationStateCreateInfoNV {
25657     pub s_type: StructureType,
25658     pub p_next: *const c_void,
25659     pub flags: PipelineCoverageModulationStateCreateFlagsNV,
25660     pub coverage_modulation_mode: CoverageModulationModeNV,
25661     pub coverage_modulation_table_enable: Bool32,
25662     pub coverage_modulation_table_count: u32,
25663     pub p_coverage_modulation_table: *const f32,
25664 }
25665 impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV {
default() -> PipelineCoverageModulationStateCreateInfoNV25666     fn default() -> PipelineCoverageModulationStateCreateInfoNV {
25667         PipelineCoverageModulationStateCreateInfoNV {
25668             s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
25669             p_next: ::std::ptr::null(),
25670             flags: PipelineCoverageModulationStateCreateFlagsNV::default(),
25671             coverage_modulation_mode: CoverageModulationModeNV::default(),
25672             coverage_modulation_table_enable: Bool32::default(),
25673             coverage_modulation_table_count: u32::default(),
25674             p_coverage_modulation_table: ::std::ptr::null(),
25675         }
25676     }
25677 }
25678 impl PipelineCoverageModulationStateCreateInfoNV {
builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a>25679     pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
25680         PipelineCoverageModulationStateCreateInfoNVBuilder {
25681             inner: PipelineCoverageModulationStateCreateInfoNV::default(),
25682             marker: ::std::marker::PhantomData,
25683         }
25684     }
25685 }
25686 #[repr(transparent)]
25687 pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
25688     inner: PipelineCoverageModulationStateCreateInfoNV,
25689     marker: ::std::marker::PhantomData<&'a ()>,
25690 }
25691 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
25692     for PipelineCoverageModulationStateCreateInfoNVBuilder<'_>
25693 {
25694 }
25695 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
25696     for PipelineCoverageModulationStateCreateInfoNV
25697 {
25698 }
25699 impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
25700     type Target = PipelineCoverageModulationStateCreateInfoNV;
deref(&self) -> &Self::Target25701     fn deref(&self) -> &Self::Target {
25702         &self.inner
25703     }
25704 }
25705 impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25706     fn deref_mut(&mut self) -> &mut Self::Target {
25707         &mut self.inner
25708     }
25709 }
25710 impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
flags( mut self, flags: PipelineCoverageModulationStateCreateFlagsNV, ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a>25711     pub fn flags(
25712         mut self,
25713         flags: PipelineCoverageModulationStateCreateFlagsNV,
25714     ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
25715         self.inner.flags = flags;
25716         self
25717     }
coverage_modulation_mode( mut self, coverage_modulation_mode: CoverageModulationModeNV, ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a>25718     pub fn coverage_modulation_mode(
25719         mut self,
25720         coverage_modulation_mode: CoverageModulationModeNV,
25721     ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
25722         self.inner.coverage_modulation_mode = coverage_modulation_mode;
25723         self
25724     }
coverage_modulation_table_enable( mut self, coverage_modulation_table_enable: bool, ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a>25725     pub fn coverage_modulation_table_enable(
25726         mut self,
25727         coverage_modulation_table_enable: bool,
25728     ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
25729         self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into();
25730         self
25731     }
coverage_modulation_table( mut self, coverage_modulation_table: &'a [f32], ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a>25732     pub fn coverage_modulation_table(
25733         mut self,
25734         coverage_modulation_table: &'a [f32],
25735     ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
25736         self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _;
25737         self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr();
25738         self
25739     }
25740     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25741     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25742     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCoverageModulationStateCreateInfoNV25743     pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV {
25744         self.inner
25745     }
25746 }
25747 #[repr(C)]
25748 #[derive(Copy, Clone, Debug)]
25749 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatListCreateInfo.html>"]
25750 pub struct ImageFormatListCreateInfo {
25751     pub s_type: StructureType,
25752     pub p_next: *const c_void,
25753     pub view_format_count: u32,
25754     pub p_view_formats: *const Format,
25755 }
25756 impl ::std::default::Default for ImageFormatListCreateInfo {
default() -> ImageFormatListCreateInfo25757     fn default() -> ImageFormatListCreateInfo {
25758         ImageFormatListCreateInfo {
25759             s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO,
25760             p_next: ::std::ptr::null(),
25761             view_format_count: u32::default(),
25762             p_view_formats: ::std::ptr::null(),
25763         }
25764     }
25765 }
25766 impl ImageFormatListCreateInfo {
builder<'a>() -> ImageFormatListCreateInfoBuilder<'a>25767     pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> {
25768         ImageFormatListCreateInfoBuilder {
25769             inner: ImageFormatListCreateInfo::default(),
25770             marker: ::std::marker::PhantomData,
25771         }
25772     }
25773 }
25774 #[repr(transparent)]
25775 pub struct ImageFormatListCreateInfoBuilder<'a> {
25776     inner: ImageFormatListCreateInfo,
25777     marker: ::std::marker::PhantomData<&'a ()>,
25778 }
25779 unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {}
25780 unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {}
25781 unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {}
25782 unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {}
25783 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {}
25784 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {}
25785 impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> {
25786     type Target = ImageFormatListCreateInfo;
deref(&self) -> &Self::Target25787     fn deref(&self) -> &Self::Target {
25788         &self.inner
25789     }
25790 }
25791 impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25792     fn deref_mut(&mut self) -> &mut Self::Target {
25793         &mut self.inner
25794     }
25795 }
25796 impl<'a> ImageFormatListCreateInfoBuilder<'a> {
view_formats( mut self, view_formats: &'a [Format], ) -> ImageFormatListCreateInfoBuilder<'a>25797     pub fn view_formats(
25798         mut self,
25799         view_formats: &'a [Format],
25800     ) -> ImageFormatListCreateInfoBuilder<'a> {
25801         self.inner.view_format_count = view_formats.len() as _;
25802         self.inner.p_view_formats = view_formats.as_ptr();
25803         self
25804     }
25805     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25806     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25807     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageFormatListCreateInfo25808     pub fn build(self) -> ImageFormatListCreateInfo {
25809         self.inner
25810     }
25811 }
25812 #[repr(C)]
25813 #[derive(Copy, Clone, Debug)]
25814 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateInfoEXT.html>"]
25815 pub struct ValidationCacheCreateInfoEXT {
25816     pub s_type: StructureType,
25817     pub p_next: *const c_void,
25818     pub flags: ValidationCacheCreateFlagsEXT,
25819     pub initial_data_size: usize,
25820     pub p_initial_data: *const c_void,
25821 }
25822 impl ::std::default::Default for ValidationCacheCreateInfoEXT {
default() -> ValidationCacheCreateInfoEXT25823     fn default() -> ValidationCacheCreateInfoEXT {
25824         ValidationCacheCreateInfoEXT {
25825             s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT,
25826             p_next: ::std::ptr::null(),
25827             flags: ValidationCacheCreateFlagsEXT::default(),
25828             initial_data_size: usize::default(),
25829             p_initial_data: ::std::ptr::null(),
25830         }
25831     }
25832 }
25833 impl ValidationCacheCreateInfoEXT {
builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a>25834     pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> {
25835         ValidationCacheCreateInfoEXTBuilder {
25836             inner: ValidationCacheCreateInfoEXT::default(),
25837             marker: ::std::marker::PhantomData,
25838         }
25839     }
25840 }
25841 #[repr(transparent)]
25842 pub struct ValidationCacheCreateInfoEXTBuilder<'a> {
25843     inner: ValidationCacheCreateInfoEXT,
25844     marker: ::std::marker::PhantomData<&'a ()>,
25845 }
25846 pub unsafe trait ExtendsValidationCacheCreateInfoEXT {}
25847 impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
25848     type Target = ValidationCacheCreateInfoEXT;
deref(&self) -> &Self::Target25849     fn deref(&self) -> &Self::Target {
25850         &self.inner
25851     }
25852 }
25853 impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25854     fn deref_mut(&mut self) -> &mut Self::Target {
25855         &mut self.inner
25856     }
25857 }
25858 impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
flags( mut self, flags: ValidationCacheCreateFlagsEXT, ) -> ValidationCacheCreateInfoEXTBuilder<'a>25859     pub fn flags(
25860         mut self,
25861         flags: ValidationCacheCreateFlagsEXT,
25862     ) -> ValidationCacheCreateInfoEXTBuilder<'a> {
25863         self.inner.flags = flags;
25864         self
25865     }
initial_data( mut self, initial_data: &'a [u8], ) -> ValidationCacheCreateInfoEXTBuilder<'a>25866     pub fn initial_data(
25867         mut self,
25868         initial_data: &'a [u8],
25869     ) -> ValidationCacheCreateInfoEXTBuilder<'a> {
25870         self.inner.initial_data_size = initial_data.len() as _;
25871         self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
25872         self
25873     }
25874     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
25875     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
25876     #[doc = r" valid extension structs can be pushed into the chain."]
25877     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
25878     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsValidationCacheCreateInfoEXT>( mut self, next: &'a mut T, ) -> ValidationCacheCreateInfoEXTBuilder<'a>25879     pub fn push_next<T: ExtendsValidationCacheCreateInfoEXT>(
25880         mut self,
25881         next: &'a mut T,
25882     ) -> ValidationCacheCreateInfoEXTBuilder<'a> {
25883         unsafe {
25884             let next_ptr = next as *mut T as *mut BaseOutStructure;
25885             let last_next = ptr_chain_iter(next).last().unwrap();
25886             (*last_next).p_next = self.inner.p_next as _;
25887             self.inner.p_next = next_ptr as _;
25888         }
25889         self
25890     }
25891     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25892     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25893     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ValidationCacheCreateInfoEXT25894     pub fn build(self) -> ValidationCacheCreateInfoEXT {
25895         self.inner
25896     }
25897 }
25898 #[repr(C)]
25899 #[derive(Copy, Clone, Debug)]
25900 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>"]
25901 pub struct ShaderModuleValidationCacheCreateInfoEXT {
25902     pub s_type: StructureType,
25903     pub p_next: *const c_void,
25904     pub validation_cache: ValidationCacheEXT,
25905 }
25906 impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT {
default() -> ShaderModuleValidationCacheCreateInfoEXT25907     fn default() -> ShaderModuleValidationCacheCreateInfoEXT {
25908         ShaderModuleValidationCacheCreateInfoEXT {
25909             s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
25910             p_next: ::std::ptr::null(),
25911             validation_cache: ValidationCacheEXT::default(),
25912         }
25913     }
25914 }
25915 impl ShaderModuleValidationCacheCreateInfoEXT {
builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a>25916     pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
25917         ShaderModuleValidationCacheCreateInfoEXTBuilder {
25918             inner: ShaderModuleValidationCacheCreateInfoEXT::default(),
25919             marker: ::std::marker::PhantomData,
25920         }
25921     }
25922 }
25923 #[repr(transparent)]
25924 pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
25925     inner: ShaderModuleValidationCacheCreateInfoEXT,
25926     marker: ::std::marker::PhantomData<&'a ()>,
25927 }
25928 unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {}
25929 unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
25930 impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
25931     type Target = ShaderModuleValidationCacheCreateInfoEXT;
deref(&self) -> &Self::Target25932     fn deref(&self) -> &Self::Target {
25933         &self.inner
25934     }
25935 }
25936 impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25937     fn deref_mut(&mut self) -> &mut Self::Target {
25938         &mut self.inner
25939     }
25940 }
25941 impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
validation_cache( mut self, validation_cache: ValidationCacheEXT, ) -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a>25942     pub fn validation_cache(
25943         mut self,
25944         validation_cache: ValidationCacheEXT,
25945     ) -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
25946         self.inner.validation_cache = validation_cache;
25947         self
25948     }
25949     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
25950     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
25951     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderModuleValidationCacheCreateInfoEXT25952     pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT {
25953         self.inner
25954     }
25955 }
25956 #[repr(C)]
25957 #[derive(Copy, Clone, Debug)]
25958 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html>"]
25959 pub struct PhysicalDeviceMaintenance3Properties {
25960     pub s_type: StructureType,
25961     pub p_next: *mut c_void,
25962     pub max_per_set_descriptors: u32,
25963     pub max_memory_allocation_size: DeviceSize,
25964 }
25965 impl ::std::default::Default for PhysicalDeviceMaintenance3Properties {
default() -> PhysicalDeviceMaintenance3Properties25966     fn default() -> PhysicalDeviceMaintenance3Properties {
25967         PhysicalDeviceMaintenance3Properties {
25968             s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
25969             p_next: ::std::ptr::null_mut(),
25970             max_per_set_descriptors: u32::default(),
25971             max_memory_allocation_size: DeviceSize::default(),
25972         }
25973     }
25974 }
25975 impl PhysicalDeviceMaintenance3Properties {
builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a>25976     pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
25977         PhysicalDeviceMaintenance3PropertiesBuilder {
25978             inner: PhysicalDeviceMaintenance3Properties::default(),
25979             marker: ::std::marker::PhantomData,
25980         }
25981     }
25982 }
25983 #[repr(transparent)]
25984 pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
25985     inner: PhysicalDeviceMaintenance3Properties,
25986     marker: ::std::marker::PhantomData<&'a ()>,
25987 }
25988 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {}
25989 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {}
25990 impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
25991     type Target = PhysicalDeviceMaintenance3Properties;
deref(&self) -> &Self::Target25992     fn deref(&self) -> &Self::Target {
25993         &self.inner
25994     }
25995 }
25996 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target25997     fn deref_mut(&mut self) -> &mut Self::Target {
25998         &mut self.inner
25999     }
26000 }
26001 impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
max_per_set_descriptors( mut self, max_per_set_descriptors: u32, ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a>26002     pub fn max_per_set_descriptors(
26003         mut self,
26004         max_per_set_descriptors: u32,
26005     ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
26006         self.inner.max_per_set_descriptors = max_per_set_descriptors;
26007         self
26008     }
max_memory_allocation_size( mut self, max_memory_allocation_size: DeviceSize, ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a>26009     pub fn max_memory_allocation_size(
26010         mut self,
26011         max_memory_allocation_size: DeviceSize,
26012     ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
26013         self.inner.max_memory_allocation_size = max_memory_allocation_size;
26014         self
26015     }
26016     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26017     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26018     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMaintenance3Properties26019     pub fn build(self) -> PhysicalDeviceMaintenance3Properties {
26020         self.inner
26021     }
26022 }
26023 #[repr(C)]
26024 #[derive(Copy, Clone, Debug)]
26025 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutSupport.html>"]
26026 pub struct DescriptorSetLayoutSupport {
26027     pub s_type: StructureType,
26028     pub p_next: *mut c_void,
26029     pub supported: Bool32,
26030 }
26031 impl ::std::default::Default for DescriptorSetLayoutSupport {
default() -> DescriptorSetLayoutSupport26032     fn default() -> DescriptorSetLayoutSupport {
26033         DescriptorSetLayoutSupport {
26034             s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT,
26035             p_next: ::std::ptr::null_mut(),
26036             supported: Bool32::default(),
26037         }
26038     }
26039 }
26040 impl DescriptorSetLayoutSupport {
builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a>26041     pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> {
26042         DescriptorSetLayoutSupportBuilder {
26043             inner: DescriptorSetLayoutSupport::default(),
26044             marker: ::std::marker::PhantomData,
26045         }
26046     }
26047 }
26048 #[repr(transparent)]
26049 pub struct DescriptorSetLayoutSupportBuilder<'a> {
26050     inner: DescriptorSetLayoutSupport,
26051     marker: ::std::marker::PhantomData<&'a ()>,
26052 }
26053 pub unsafe trait ExtendsDescriptorSetLayoutSupport {}
26054 impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> {
26055     type Target = DescriptorSetLayoutSupport;
deref(&self) -> &Self::Target26056     fn deref(&self) -> &Self::Target {
26057         &self.inner
26058     }
26059 }
26060 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26061     fn deref_mut(&mut self) -> &mut Self::Target {
26062         &mut self.inner
26063     }
26064 }
26065 impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
supported(mut self, supported: bool) -> DescriptorSetLayoutSupportBuilder<'a>26066     pub fn supported(mut self, supported: bool) -> DescriptorSetLayoutSupportBuilder<'a> {
26067         self.inner.supported = supported.into();
26068         self
26069     }
26070     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
26071     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
26072     #[doc = r" valid extension structs can be pushed into the chain."]
26073     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
26074     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDescriptorSetLayoutSupport>( mut self, next: &'a mut T, ) -> DescriptorSetLayoutSupportBuilder<'a>26075     pub fn push_next<T: ExtendsDescriptorSetLayoutSupport>(
26076         mut self,
26077         next: &'a mut T,
26078     ) -> DescriptorSetLayoutSupportBuilder<'a> {
26079         unsafe {
26080             let next_ptr = next as *mut T as *mut BaseOutStructure;
26081             let last_next = ptr_chain_iter(next).last().unwrap();
26082             (*last_next).p_next = self.inner.p_next as _;
26083             self.inner.p_next = next_ptr as _;
26084         }
26085         self
26086     }
26087     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26088     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26089     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutSupport26090     pub fn build(self) -> DescriptorSetLayoutSupport {
26091         self.inner
26092     }
26093 }
26094 #[repr(C)]
26095 #[derive(Copy, Clone, Debug)]
26096 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>"]
26097 pub struct PhysicalDeviceShaderDrawParametersFeatures {
26098     pub s_type: StructureType,
26099     pub p_next: *mut c_void,
26100     pub shader_draw_parameters: Bool32,
26101 }
26102 impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures {
default() -> PhysicalDeviceShaderDrawParametersFeatures26103     fn default() -> PhysicalDeviceShaderDrawParametersFeatures {
26104         PhysicalDeviceShaderDrawParametersFeatures {
26105             s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
26106             p_next: ::std::ptr::null_mut(),
26107             shader_draw_parameters: Bool32::default(),
26108         }
26109     }
26110 }
26111 impl PhysicalDeviceShaderDrawParametersFeatures {
builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a>26112     pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26113         PhysicalDeviceShaderDrawParametersFeaturesBuilder {
26114             inner: PhysicalDeviceShaderDrawParametersFeatures::default(),
26115             marker: ::std::marker::PhantomData,
26116         }
26117     }
26118 }
26119 #[repr(transparent)]
26120 pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26121     inner: PhysicalDeviceShaderDrawParametersFeatures,
26122     marker: ::std::marker::PhantomData<&'a ()>,
26123 }
26124 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {}
26125 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {}
26126 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26127     type Target = PhysicalDeviceShaderDrawParametersFeatures;
deref(&self) -> &Self::Target26128     fn deref(&self) -> &Self::Target {
26129         &self.inner
26130     }
26131 }
26132 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26133     fn deref_mut(&mut self) -> &mut Self::Target {
26134         &mut self.inner
26135     }
26136 }
26137 impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
shader_draw_parameters( mut self, shader_draw_parameters: bool, ) -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a>26138     pub fn shader_draw_parameters(
26139         mut self,
26140         shader_draw_parameters: bool,
26141     ) -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
26142         self.inner.shader_draw_parameters = shader_draw_parameters.into();
26143         self
26144     }
26145     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26146     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26147     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderDrawParametersFeatures26148     pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures {
26149         self.inner
26150     }
26151 }
26152 #[repr(C)]
26153 #[derive(Copy, Clone, Debug)]
26154 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>"]
26155 pub struct PhysicalDeviceShaderFloat16Int8Features {
26156     pub s_type: StructureType,
26157     pub p_next: *mut c_void,
26158     pub shader_float16: Bool32,
26159     pub shader_int8: Bool32,
26160 }
26161 impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features {
default() -> PhysicalDeviceShaderFloat16Int8Features26162     fn default() -> PhysicalDeviceShaderFloat16Int8Features {
26163         PhysicalDeviceShaderFloat16Int8Features {
26164             s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
26165             p_next: ::std::ptr::null_mut(),
26166             shader_float16: Bool32::default(),
26167             shader_int8: Bool32::default(),
26168         }
26169     }
26170 }
26171 impl PhysicalDeviceShaderFloat16Int8Features {
builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a>26172     pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26173         PhysicalDeviceShaderFloat16Int8FeaturesBuilder {
26174             inner: PhysicalDeviceShaderFloat16Int8Features::default(),
26175             marker: ::std::marker::PhantomData,
26176         }
26177     }
26178 }
26179 #[repr(transparent)]
26180 pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26181     inner: PhysicalDeviceShaderFloat16Int8Features,
26182     marker: ::std::marker::PhantomData<&'a ()>,
26183 }
26184 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
26185 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {}
26186 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26187     type Target = PhysicalDeviceShaderFloat16Int8Features;
deref(&self) -> &Self::Target26188     fn deref(&self) -> &Self::Target {
26189         &self.inner
26190     }
26191 }
26192 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26193     fn deref_mut(&mut self) -> &mut Self::Target {
26194         &mut self.inner
26195     }
26196 }
26197 impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
shader_float16( mut self, shader_float16: bool, ) -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a>26198     pub fn shader_float16(
26199         mut self,
26200         shader_float16: bool,
26201     ) -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26202         self.inner.shader_float16 = shader_float16.into();
26203         self
26204     }
shader_int8( mut self, shader_int8: bool, ) -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a>26205     pub fn shader_int8(
26206         mut self,
26207         shader_int8: bool,
26208     ) -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
26209         self.inner.shader_int8 = shader_int8.into();
26210         self
26211     }
26212     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26213     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26214     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderFloat16Int8Features26215     pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features {
26216         self.inner
26217     }
26218 }
26219 #[repr(C)]
26220 #[derive(Copy, Clone, Debug)]
26221 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html>"]
26222 pub struct PhysicalDeviceFloatControlsProperties {
26223     pub s_type: StructureType,
26224     pub p_next: *mut c_void,
26225     pub denorm_behavior_independence: ShaderFloatControlsIndependence,
26226     pub rounding_mode_independence: ShaderFloatControlsIndependence,
26227     pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
26228     pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
26229     pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
26230     pub shader_denorm_preserve_float16: Bool32,
26231     pub shader_denorm_preserve_float32: Bool32,
26232     pub shader_denorm_preserve_float64: Bool32,
26233     pub shader_denorm_flush_to_zero_float16: Bool32,
26234     pub shader_denorm_flush_to_zero_float32: Bool32,
26235     pub shader_denorm_flush_to_zero_float64: Bool32,
26236     pub shader_rounding_mode_rte_float16: Bool32,
26237     pub shader_rounding_mode_rte_float32: Bool32,
26238     pub shader_rounding_mode_rte_float64: Bool32,
26239     pub shader_rounding_mode_rtz_float16: Bool32,
26240     pub shader_rounding_mode_rtz_float32: Bool32,
26241     pub shader_rounding_mode_rtz_float64: Bool32,
26242 }
26243 impl ::std::default::Default for PhysicalDeviceFloatControlsProperties {
default() -> PhysicalDeviceFloatControlsProperties26244     fn default() -> PhysicalDeviceFloatControlsProperties {
26245         PhysicalDeviceFloatControlsProperties {
26246             s_type: StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
26247             p_next: ::std::ptr::null_mut(),
26248             denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
26249             rounding_mode_independence: ShaderFloatControlsIndependence::default(),
26250             shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
26251             shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
26252             shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
26253             shader_denorm_preserve_float16: Bool32::default(),
26254             shader_denorm_preserve_float32: Bool32::default(),
26255             shader_denorm_preserve_float64: Bool32::default(),
26256             shader_denorm_flush_to_zero_float16: Bool32::default(),
26257             shader_denorm_flush_to_zero_float32: Bool32::default(),
26258             shader_denorm_flush_to_zero_float64: Bool32::default(),
26259             shader_rounding_mode_rte_float16: Bool32::default(),
26260             shader_rounding_mode_rte_float32: Bool32::default(),
26261             shader_rounding_mode_rte_float64: Bool32::default(),
26262             shader_rounding_mode_rtz_float16: Bool32::default(),
26263             shader_rounding_mode_rtz_float32: Bool32::default(),
26264             shader_rounding_mode_rtz_float64: Bool32::default(),
26265         }
26266     }
26267 }
26268 impl PhysicalDeviceFloatControlsProperties {
builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26269     pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26270         PhysicalDeviceFloatControlsPropertiesBuilder {
26271             inner: PhysicalDeviceFloatControlsProperties::default(),
26272             marker: ::std::marker::PhantomData,
26273         }
26274     }
26275 }
26276 #[repr(transparent)]
26277 pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26278     inner: PhysicalDeviceFloatControlsProperties,
26279     marker: ::std::marker::PhantomData<&'a ()>,
26280 }
26281 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {}
26282 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {}
26283 impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26284     type Target = PhysicalDeviceFloatControlsProperties;
deref(&self) -> &Self::Target26285     fn deref(&self) -> &Self::Target {
26286         &self.inner
26287     }
26288 }
26289 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26290     fn deref_mut(&mut self) -> &mut Self::Target {
26291         &mut self.inner
26292     }
26293 }
26294 impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
denorm_behavior_independence( mut self, denorm_behavior_independence: ShaderFloatControlsIndependence, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26295     pub fn denorm_behavior_independence(
26296         mut self,
26297         denorm_behavior_independence: ShaderFloatControlsIndependence,
26298     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26299         self.inner.denorm_behavior_independence = denorm_behavior_independence;
26300         self
26301     }
rounding_mode_independence( mut self, rounding_mode_independence: ShaderFloatControlsIndependence, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26302     pub fn rounding_mode_independence(
26303         mut self,
26304         rounding_mode_independence: ShaderFloatControlsIndependence,
26305     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26306         self.inner.rounding_mode_independence = rounding_mode_independence;
26307         self
26308     }
shader_signed_zero_inf_nan_preserve_float16( mut self, shader_signed_zero_inf_nan_preserve_float16: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26309     pub fn shader_signed_zero_inf_nan_preserve_float16(
26310         mut self,
26311         shader_signed_zero_inf_nan_preserve_float16: bool,
26312     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26313         self.inner.shader_signed_zero_inf_nan_preserve_float16 =
26314             shader_signed_zero_inf_nan_preserve_float16.into();
26315         self
26316     }
shader_signed_zero_inf_nan_preserve_float32( mut self, shader_signed_zero_inf_nan_preserve_float32: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26317     pub fn shader_signed_zero_inf_nan_preserve_float32(
26318         mut self,
26319         shader_signed_zero_inf_nan_preserve_float32: bool,
26320     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26321         self.inner.shader_signed_zero_inf_nan_preserve_float32 =
26322             shader_signed_zero_inf_nan_preserve_float32.into();
26323         self
26324     }
shader_signed_zero_inf_nan_preserve_float64( mut self, shader_signed_zero_inf_nan_preserve_float64: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26325     pub fn shader_signed_zero_inf_nan_preserve_float64(
26326         mut self,
26327         shader_signed_zero_inf_nan_preserve_float64: bool,
26328     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26329         self.inner.shader_signed_zero_inf_nan_preserve_float64 =
26330             shader_signed_zero_inf_nan_preserve_float64.into();
26331         self
26332     }
shader_denorm_preserve_float16( mut self, shader_denorm_preserve_float16: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26333     pub fn shader_denorm_preserve_float16(
26334         mut self,
26335         shader_denorm_preserve_float16: bool,
26336     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26337         self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
26338         self
26339     }
shader_denorm_preserve_float32( mut self, shader_denorm_preserve_float32: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26340     pub fn shader_denorm_preserve_float32(
26341         mut self,
26342         shader_denorm_preserve_float32: bool,
26343     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26344         self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
26345         self
26346     }
shader_denorm_preserve_float64( mut self, shader_denorm_preserve_float64: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26347     pub fn shader_denorm_preserve_float64(
26348         mut self,
26349         shader_denorm_preserve_float64: bool,
26350     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26351         self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
26352         self
26353     }
shader_denorm_flush_to_zero_float16( mut self, shader_denorm_flush_to_zero_float16: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26354     pub fn shader_denorm_flush_to_zero_float16(
26355         mut self,
26356         shader_denorm_flush_to_zero_float16: bool,
26357     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26358         self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
26359         self
26360     }
shader_denorm_flush_to_zero_float32( mut self, shader_denorm_flush_to_zero_float32: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26361     pub fn shader_denorm_flush_to_zero_float32(
26362         mut self,
26363         shader_denorm_flush_to_zero_float32: bool,
26364     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26365         self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
26366         self
26367     }
shader_denorm_flush_to_zero_float64( mut self, shader_denorm_flush_to_zero_float64: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26368     pub fn shader_denorm_flush_to_zero_float64(
26369         mut self,
26370         shader_denorm_flush_to_zero_float64: bool,
26371     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26372         self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
26373         self
26374     }
shader_rounding_mode_rte_float16( mut self, shader_rounding_mode_rte_float16: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26375     pub fn shader_rounding_mode_rte_float16(
26376         mut self,
26377         shader_rounding_mode_rte_float16: bool,
26378     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26379         self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
26380         self
26381     }
shader_rounding_mode_rte_float32( mut self, shader_rounding_mode_rte_float32: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26382     pub fn shader_rounding_mode_rte_float32(
26383         mut self,
26384         shader_rounding_mode_rte_float32: bool,
26385     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26386         self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
26387         self
26388     }
shader_rounding_mode_rte_float64( mut self, shader_rounding_mode_rte_float64: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26389     pub fn shader_rounding_mode_rte_float64(
26390         mut self,
26391         shader_rounding_mode_rte_float64: bool,
26392     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26393         self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
26394         self
26395     }
shader_rounding_mode_rtz_float16( mut self, shader_rounding_mode_rtz_float16: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26396     pub fn shader_rounding_mode_rtz_float16(
26397         mut self,
26398         shader_rounding_mode_rtz_float16: bool,
26399     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26400         self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
26401         self
26402     }
shader_rounding_mode_rtz_float32( mut self, shader_rounding_mode_rtz_float32: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26403     pub fn shader_rounding_mode_rtz_float32(
26404         mut self,
26405         shader_rounding_mode_rtz_float32: bool,
26406     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26407         self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
26408         self
26409     }
shader_rounding_mode_rtz_float64( mut self, shader_rounding_mode_rtz_float64: bool, ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a>26410     pub fn shader_rounding_mode_rtz_float64(
26411         mut self,
26412         shader_rounding_mode_rtz_float64: bool,
26413     ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
26414         self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
26415         self
26416     }
26417     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26418     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26419     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFloatControlsProperties26420     pub fn build(self) -> PhysicalDeviceFloatControlsProperties {
26421         self.inner
26422     }
26423 }
26424 #[repr(C)]
26425 #[derive(Copy, Clone, Debug)]
26426 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>"]
26427 pub struct PhysicalDeviceHostQueryResetFeatures {
26428     pub s_type: StructureType,
26429     pub p_next: *mut c_void,
26430     pub host_query_reset: Bool32,
26431 }
26432 impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures {
default() -> PhysicalDeviceHostQueryResetFeatures26433     fn default() -> PhysicalDeviceHostQueryResetFeatures {
26434         PhysicalDeviceHostQueryResetFeatures {
26435             s_type: StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
26436             p_next: ::std::ptr::null_mut(),
26437             host_query_reset: Bool32::default(),
26438         }
26439     }
26440 }
26441 impl PhysicalDeviceHostQueryResetFeatures {
builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a>26442     pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
26443         PhysicalDeviceHostQueryResetFeaturesBuilder {
26444             inner: PhysicalDeviceHostQueryResetFeatures::default(),
26445             marker: ::std::marker::PhantomData,
26446         }
26447     }
26448 }
26449 #[repr(transparent)]
26450 pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
26451     inner: PhysicalDeviceHostQueryResetFeatures,
26452     marker: ::std::marker::PhantomData<&'a ()>,
26453 }
26454 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
26455 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {}
26456 impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
26457     type Target = PhysicalDeviceHostQueryResetFeatures;
deref(&self) -> &Self::Target26458     fn deref(&self) -> &Self::Target {
26459         &self.inner
26460     }
26461 }
26462 impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26463     fn deref_mut(&mut self) -> &mut Self::Target {
26464         &mut self.inner
26465     }
26466 }
26467 impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
host_query_reset( mut self, host_query_reset: bool, ) -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a>26468     pub fn host_query_reset(
26469         mut self,
26470         host_query_reset: bool,
26471     ) -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
26472         self.inner.host_query_reset = host_query_reset.into();
26473         self
26474     }
26475     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26476     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26477     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceHostQueryResetFeatures26478     pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures {
26479         self.inner
26480     }
26481 }
26482 #[repr(C)]
26483 #[derive(Copy, Clone, Default, Debug)]
26484 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkNativeBufferUsage2ANDROID.html>"]
26485 pub struct NativeBufferUsage2ANDROID {
26486     pub consumer: u64,
26487     pub producer: u64,
26488 }
26489 impl NativeBufferUsage2ANDROID {
builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a>26490     pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> {
26491         NativeBufferUsage2ANDROIDBuilder {
26492             inner: NativeBufferUsage2ANDROID::default(),
26493             marker: ::std::marker::PhantomData,
26494         }
26495     }
26496 }
26497 #[repr(transparent)]
26498 pub struct NativeBufferUsage2ANDROIDBuilder<'a> {
26499     inner: NativeBufferUsage2ANDROID,
26500     marker: ::std::marker::PhantomData<&'a ()>,
26501 }
26502 impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> {
26503     type Target = NativeBufferUsage2ANDROID;
deref(&self) -> &Self::Target26504     fn deref(&self) -> &Self::Target {
26505         &self.inner
26506     }
26507 }
26508 impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26509     fn deref_mut(&mut self) -> &mut Self::Target {
26510         &mut self.inner
26511     }
26512 }
26513 impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> {
consumer(mut self, consumer: u64) -> NativeBufferUsage2ANDROIDBuilder<'a>26514     pub fn consumer(mut self, consumer: u64) -> NativeBufferUsage2ANDROIDBuilder<'a> {
26515         self.inner.consumer = consumer;
26516         self
26517     }
producer(mut self, producer: u64) -> NativeBufferUsage2ANDROIDBuilder<'a>26518     pub fn producer(mut self, producer: u64) -> NativeBufferUsage2ANDROIDBuilder<'a> {
26519         self.inner.producer = producer;
26520         self
26521     }
26522     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26523     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26524     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> NativeBufferUsage2ANDROID26525     pub fn build(self) -> NativeBufferUsage2ANDROID {
26526         self.inner
26527     }
26528 }
26529 #[repr(C)]
26530 #[derive(Copy, Clone, Debug)]
26531 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkNativeBufferANDROID.html>"]
26532 pub struct NativeBufferANDROID {
26533     pub s_type: StructureType,
26534     pub p_next: *const c_void,
26535     pub handle: *const c_void,
26536     pub stride: c_int,
26537     pub format: c_int,
26538     pub usage: c_int,
26539     pub usage2: NativeBufferUsage2ANDROID,
26540 }
26541 impl ::std::default::Default for NativeBufferANDROID {
default() -> NativeBufferANDROID26542     fn default() -> NativeBufferANDROID {
26543         NativeBufferANDROID {
26544             s_type: StructureType::NATIVE_BUFFER_ANDROID,
26545             p_next: ::std::ptr::null(),
26546             handle: ::std::ptr::null(),
26547             stride: c_int::default(),
26548             format: c_int::default(),
26549             usage: c_int::default(),
26550             usage2: NativeBufferUsage2ANDROID::default(),
26551         }
26552     }
26553 }
26554 impl NativeBufferANDROID {
builder<'a>() -> NativeBufferANDROIDBuilder<'a>26555     pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> {
26556         NativeBufferANDROIDBuilder {
26557             inner: NativeBufferANDROID::default(),
26558             marker: ::std::marker::PhantomData,
26559         }
26560     }
26561 }
26562 #[repr(transparent)]
26563 pub struct NativeBufferANDROIDBuilder<'a> {
26564     inner: NativeBufferANDROID,
26565     marker: ::std::marker::PhantomData<&'a ()>,
26566 }
26567 pub unsafe trait ExtendsNativeBufferANDROID {}
26568 impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> {
26569     type Target = NativeBufferANDROID;
deref(&self) -> &Self::Target26570     fn deref(&self) -> &Self::Target {
26571         &self.inner
26572     }
26573 }
26574 impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26575     fn deref_mut(&mut self) -> &mut Self::Target {
26576         &mut self.inner
26577     }
26578 }
26579 impl<'a> NativeBufferANDROIDBuilder<'a> {
handle(mut self, handle: *const c_void) -> NativeBufferANDROIDBuilder<'a>26580     pub fn handle(mut self, handle: *const c_void) -> NativeBufferANDROIDBuilder<'a> {
26581         self.inner.handle = handle;
26582         self
26583     }
stride(mut self, stride: c_int) -> NativeBufferANDROIDBuilder<'a>26584     pub fn stride(mut self, stride: c_int) -> NativeBufferANDROIDBuilder<'a> {
26585         self.inner.stride = stride;
26586         self
26587     }
format(mut self, format: c_int) -> NativeBufferANDROIDBuilder<'a>26588     pub fn format(mut self, format: c_int) -> NativeBufferANDROIDBuilder<'a> {
26589         self.inner.format = format;
26590         self
26591     }
usage(mut self, usage: c_int) -> NativeBufferANDROIDBuilder<'a>26592     pub fn usage(mut self, usage: c_int) -> NativeBufferANDROIDBuilder<'a> {
26593         self.inner.usage = usage;
26594         self
26595     }
usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> NativeBufferANDROIDBuilder<'a>26596     pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> NativeBufferANDROIDBuilder<'a> {
26597         self.inner.usage2 = usage2;
26598         self
26599     }
26600     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
26601     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
26602     #[doc = r" valid extension structs can be pushed into the chain."]
26603     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
26604     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsNativeBufferANDROID>( mut self, next: &'a mut T, ) -> NativeBufferANDROIDBuilder<'a>26605     pub fn push_next<T: ExtendsNativeBufferANDROID>(
26606         mut self,
26607         next: &'a mut T,
26608     ) -> NativeBufferANDROIDBuilder<'a> {
26609         unsafe {
26610             let next_ptr = next as *mut T as *mut BaseOutStructure;
26611             let last_next = ptr_chain_iter(next).last().unwrap();
26612             (*last_next).p_next = self.inner.p_next as _;
26613             self.inner.p_next = next_ptr as _;
26614         }
26615         self
26616     }
26617     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26618     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26619     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> NativeBufferANDROID26620     pub fn build(self) -> NativeBufferANDROID {
26621         self.inner
26622     }
26623 }
26624 #[repr(C)]
26625 #[derive(Copy, Clone, Debug)]
26626 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageCreateInfoANDROID.html>"]
26627 pub struct SwapchainImageCreateInfoANDROID {
26628     pub s_type: StructureType,
26629     pub p_next: *const c_void,
26630     pub usage: SwapchainImageUsageFlagsANDROID,
26631 }
26632 impl ::std::default::Default for SwapchainImageCreateInfoANDROID {
default() -> SwapchainImageCreateInfoANDROID26633     fn default() -> SwapchainImageCreateInfoANDROID {
26634         SwapchainImageCreateInfoANDROID {
26635             s_type: StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
26636             p_next: ::std::ptr::null(),
26637             usage: SwapchainImageUsageFlagsANDROID::default(),
26638         }
26639     }
26640 }
26641 impl SwapchainImageCreateInfoANDROID {
builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a>26642     pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
26643         SwapchainImageCreateInfoANDROIDBuilder {
26644             inner: SwapchainImageCreateInfoANDROID::default(),
26645             marker: ::std::marker::PhantomData,
26646         }
26647     }
26648 }
26649 #[repr(transparent)]
26650 pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> {
26651     inner: SwapchainImageCreateInfoANDROID,
26652     marker: ::std::marker::PhantomData<&'a ()>,
26653 }
26654 pub unsafe trait ExtendsSwapchainImageCreateInfoANDROID {}
26655 impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> {
26656     type Target = SwapchainImageCreateInfoANDROID;
deref(&self) -> &Self::Target26657     fn deref(&self) -> &Self::Target {
26658         &self.inner
26659     }
26660 }
26661 impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26662     fn deref_mut(&mut self) -> &mut Self::Target {
26663         &mut self.inner
26664     }
26665 }
26666 impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
usage( mut self, usage: SwapchainImageUsageFlagsANDROID, ) -> SwapchainImageCreateInfoANDROIDBuilder<'a>26667     pub fn usage(
26668         mut self,
26669         usage: SwapchainImageUsageFlagsANDROID,
26670     ) -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
26671         self.inner.usage = usage;
26672         self
26673     }
26674     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
26675     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
26676     #[doc = r" valid extension structs can be pushed into the chain."]
26677     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
26678     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSwapchainImageCreateInfoANDROID>( mut self, next: &'a mut T, ) -> SwapchainImageCreateInfoANDROIDBuilder<'a>26679     pub fn push_next<T: ExtendsSwapchainImageCreateInfoANDROID>(
26680         mut self,
26681         next: &'a mut T,
26682     ) -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
26683         unsafe {
26684             let next_ptr = next as *mut T as *mut BaseOutStructure;
26685             let last_next = ptr_chain_iter(next).last().unwrap();
26686             (*last_next).p_next = self.inner.p_next as _;
26687             self.inner.p_next = next_ptr as _;
26688         }
26689         self
26690     }
26691     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26692     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26693     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SwapchainImageCreateInfoANDROID26694     pub fn build(self) -> SwapchainImageCreateInfoANDROID {
26695         self.inner
26696     }
26697 }
26698 #[repr(C)]
26699 #[derive(Copy, Clone, Debug)]
26700 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentationPropertiesANDROID.html>"]
26701 pub struct PhysicalDevicePresentationPropertiesANDROID {
26702     pub s_type: StructureType,
26703     pub p_next: *const c_void,
26704     pub shared_image: Bool32,
26705 }
26706 impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID {
default() -> PhysicalDevicePresentationPropertiesANDROID26707     fn default() -> PhysicalDevicePresentationPropertiesANDROID {
26708         PhysicalDevicePresentationPropertiesANDROID {
26709             s_type: StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID,
26710             p_next: ::std::ptr::null(),
26711             shared_image: Bool32::default(),
26712         }
26713     }
26714 }
26715 impl PhysicalDevicePresentationPropertiesANDROID {
builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a>26716     pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
26717         PhysicalDevicePresentationPropertiesANDROIDBuilder {
26718             inner: PhysicalDevicePresentationPropertiesANDROID::default(),
26719             marker: ::std::marker::PhantomData,
26720         }
26721     }
26722 }
26723 #[repr(transparent)]
26724 pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
26725     inner: PhysicalDevicePresentationPropertiesANDROID,
26726     marker: ::std::marker::PhantomData<&'a ()>,
26727 }
26728 pub unsafe trait ExtendsPhysicalDevicePresentationPropertiesANDROID {}
26729 impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
26730     type Target = PhysicalDevicePresentationPropertiesANDROID;
deref(&self) -> &Self::Target26731     fn deref(&self) -> &Self::Target {
26732         &self.inner
26733     }
26734 }
26735 impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26736     fn deref_mut(&mut self) -> &mut Self::Target {
26737         &mut self.inner
26738     }
26739 }
26740 impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
shared_image( mut self, shared_image: bool, ) -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a>26741     pub fn shared_image(
26742         mut self,
26743         shared_image: bool,
26744     ) -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
26745         self.inner.shared_image = shared_image.into();
26746         self
26747     }
26748     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
26749     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
26750     #[doc = r" valid extension structs can be pushed into the chain."]
26751     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
26752     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDevicePresentationPropertiesANDROID>( mut self, next: &'a mut T, ) -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a>26753     pub fn push_next<T: ExtendsPhysicalDevicePresentationPropertiesANDROID>(
26754         mut self,
26755         next: &'a mut T,
26756     ) -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
26757         unsafe {
26758             let next_ptr = next as *mut T as *mut BaseOutStructure;
26759             let last_next = ptr_chain_iter(next).last().unwrap();
26760             (*last_next).p_next = self.inner.p_next as _;
26761             self.inner.p_next = next_ptr as _;
26762         }
26763         self
26764     }
26765     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26766     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26767     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePresentationPropertiesANDROID26768     pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID {
26769         self.inner
26770     }
26771 }
26772 #[repr(C)]
26773 #[derive(Copy, Clone, Default, Debug)]
26774 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderResourceUsageAMD.html>"]
26775 pub struct ShaderResourceUsageAMD {
26776     pub num_used_vgprs: u32,
26777     pub num_used_sgprs: u32,
26778     pub lds_size_per_local_work_group: u32,
26779     pub lds_usage_size_in_bytes: usize,
26780     pub scratch_mem_usage_in_bytes: usize,
26781 }
26782 impl ShaderResourceUsageAMD {
builder<'a>() -> ShaderResourceUsageAMDBuilder<'a>26783     pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> {
26784         ShaderResourceUsageAMDBuilder {
26785             inner: ShaderResourceUsageAMD::default(),
26786             marker: ::std::marker::PhantomData,
26787         }
26788     }
26789 }
26790 #[repr(transparent)]
26791 pub struct ShaderResourceUsageAMDBuilder<'a> {
26792     inner: ShaderResourceUsageAMD,
26793     marker: ::std::marker::PhantomData<&'a ()>,
26794 }
26795 impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> {
26796     type Target = ShaderResourceUsageAMD;
deref(&self) -> &Self::Target26797     fn deref(&self) -> &Self::Target {
26798         &self.inner
26799     }
26800 }
26801 impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26802     fn deref_mut(&mut self) -> &mut Self::Target {
26803         &mut self.inner
26804     }
26805 }
26806 impl<'a> ShaderResourceUsageAMDBuilder<'a> {
num_used_vgprs(mut self, num_used_vgprs: u32) -> ShaderResourceUsageAMDBuilder<'a>26807     pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> ShaderResourceUsageAMDBuilder<'a> {
26808         self.inner.num_used_vgprs = num_used_vgprs;
26809         self
26810     }
num_used_sgprs(mut self, num_used_sgprs: u32) -> ShaderResourceUsageAMDBuilder<'a>26811     pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> ShaderResourceUsageAMDBuilder<'a> {
26812         self.inner.num_used_sgprs = num_used_sgprs;
26813         self
26814     }
lds_size_per_local_work_group( mut self, lds_size_per_local_work_group: u32, ) -> ShaderResourceUsageAMDBuilder<'a>26815     pub fn lds_size_per_local_work_group(
26816         mut self,
26817         lds_size_per_local_work_group: u32,
26818     ) -> ShaderResourceUsageAMDBuilder<'a> {
26819         self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group;
26820         self
26821     }
lds_usage_size_in_bytes( mut self, lds_usage_size_in_bytes: usize, ) -> ShaderResourceUsageAMDBuilder<'a>26822     pub fn lds_usage_size_in_bytes(
26823         mut self,
26824         lds_usage_size_in_bytes: usize,
26825     ) -> ShaderResourceUsageAMDBuilder<'a> {
26826         self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes;
26827         self
26828     }
scratch_mem_usage_in_bytes( mut self, scratch_mem_usage_in_bytes: usize, ) -> ShaderResourceUsageAMDBuilder<'a>26829     pub fn scratch_mem_usage_in_bytes(
26830         mut self,
26831         scratch_mem_usage_in_bytes: usize,
26832     ) -> ShaderResourceUsageAMDBuilder<'a> {
26833         self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes;
26834         self
26835     }
26836     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26837     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26838     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderResourceUsageAMD26839     pub fn build(self) -> ShaderResourceUsageAMD {
26840         self.inner
26841     }
26842 }
26843 #[repr(C)]
26844 #[derive(Copy, Clone, Debug)]
26845 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStatisticsInfoAMD.html>"]
26846 pub struct ShaderStatisticsInfoAMD {
26847     pub shader_stage_mask: ShaderStageFlags,
26848     pub resource_usage: ShaderResourceUsageAMD,
26849     pub num_physical_vgprs: u32,
26850     pub num_physical_sgprs: u32,
26851     pub num_available_vgprs: u32,
26852     pub num_available_sgprs: u32,
26853     pub compute_work_group_size: [u32; 3],
26854 }
26855 impl ::std::default::Default for ShaderStatisticsInfoAMD {
default() -> ShaderStatisticsInfoAMD26856     fn default() -> ShaderStatisticsInfoAMD {
26857         ShaderStatisticsInfoAMD {
26858             shader_stage_mask: ShaderStageFlags::default(),
26859             resource_usage: ShaderResourceUsageAMD::default(),
26860             num_physical_vgprs: u32::default(),
26861             num_physical_sgprs: u32::default(),
26862             num_available_vgprs: u32::default(),
26863             num_available_sgprs: u32::default(),
26864             compute_work_group_size: unsafe { ::std::mem::zeroed() },
26865         }
26866     }
26867 }
26868 impl ShaderStatisticsInfoAMD {
builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a>26869     pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> {
26870         ShaderStatisticsInfoAMDBuilder {
26871             inner: ShaderStatisticsInfoAMD::default(),
26872             marker: ::std::marker::PhantomData,
26873         }
26874     }
26875 }
26876 #[repr(transparent)]
26877 pub struct ShaderStatisticsInfoAMDBuilder<'a> {
26878     inner: ShaderStatisticsInfoAMD,
26879     marker: ::std::marker::PhantomData<&'a ()>,
26880 }
26881 impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> {
26882     type Target = ShaderStatisticsInfoAMD;
deref(&self) -> &Self::Target26883     fn deref(&self) -> &Self::Target {
26884         &self.inner
26885     }
26886 }
26887 impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26888     fn deref_mut(&mut self) -> &mut Self::Target {
26889         &mut self.inner
26890     }
26891 }
26892 impl<'a> ShaderStatisticsInfoAMDBuilder<'a> {
shader_stage_mask( mut self, shader_stage_mask: ShaderStageFlags, ) -> ShaderStatisticsInfoAMDBuilder<'a>26893     pub fn shader_stage_mask(
26894         mut self,
26895         shader_stage_mask: ShaderStageFlags,
26896     ) -> ShaderStatisticsInfoAMDBuilder<'a> {
26897         self.inner.shader_stage_mask = shader_stage_mask;
26898         self
26899     }
resource_usage( mut self, resource_usage: ShaderResourceUsageAMD, ) -> ShaderStatisticsInfoAMDBuilder<'a>26900     pub fn resource_usage(
26901         mut self,
26902         resource_usage: ShaderResourceUsageAMD,
26903     ) -> ShaderStatisticsInfoAMDBuilder<'a> {
26904         self.inner.resource_usage = resource_usage;
26905         self
26906     }
num_physical_vgprs( mut self, num_physical_vgprs: u32, ) -> ShaderStatisticsInfoAMDBuilder<'a>26907     pub fn num_physical_vgprs(
26908         mut self,
26909         num_physical_vgprs: u32,
26910     ) -> ShaderStatisticsInfoAMDBuilder<'a> {
26911         self.inner.num_physical_vgprs = num_physical_vgprs;
26912         self
26913     }
num_physical_sgprs( mut self, num_physical_sgprs: u32, ) -> ShaderStatisticsInfoAMDBuilder<'a>26914     pub fn num_physical_sgprs(
26915         mut self,
26916         num_physical_sgprs: u32,
26917     ) -> ShaderStatisticsInfoAMDBuilder<'a> {
26918         self.inner.num_physical_sgprs = num_physical_sgprs;
26919         self
26920     }
num_available_vgprs( mut self, num_available_vgprs: u32, ) -> ShaderStatisticsInfoAMDBuilder<'a>26921     pub fn num_available_vgprs(
26922         mut self,
26923         num_available_vgprs: u32,
26924     ) -> ShaderStatisticsInfoAMDBuilder<'a> {
26925         self.inner.num_available_vgprs = num_available_vgprs;
26926         self
26927     }
num_available_sgprs( mut self, num_available_sgprs: u32, ) -> ShaderStatisticsInfoAMDBuilder<'a>26928     pub fn num_available_sgprs(
26929         mut self,
26930         num_available_sgprs: u32,
26931     ) -> ShaderStatisticsInfoAMDBuilder<'a> {
26932         self.inner.num_available_sgprs = num_available_sgprs;
26933         self
26934     }
compute_work_group_size( mut self, compute_work_group_size: [u32; 3], ) -> ShaderStatisticsInfoAMDBuilder<'a>26935     pub fn compute_work_group_size(
26936         mut self,
26937         compute_work_group_size: [u32; 3],
26938     ) -> ShaderStatisticsInfoAMDBuilder<'a> {
26939         self.inner.compute_work_group_size = compute_work_group_size;
26940         self
26941     }
26942     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
26943     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
26944     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShaderStatisticsInfoAMD26945     pub fn build(self) -> ShaderStatisticsInfoAMD {
26946         self.inner
26947     }
26948 }
26949 #[repr(C)]
26950 #[derive(Copy, Clone, Debug)]
26951 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoEXT.html>"]
26952 pub struct DeviceQueueGlobalPriorityCreateInfoEXT {
26953     pub s_type: StructureType,
26954     pub p_next: *const c_void,
26955     pub global_priority: QueueGlobalPriorityEXT,
26956 }
26957 impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoEXT {
default() -> DeviceQueueGlobalPriorityCreateInfoEXT26958     fn default() -> DeviceQueueGlobalPriorityCreateInfoEXT {
26959         DeviceQueueGlobalPriorityCreateInfoEXT {
26960             s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
26961             p_next: ::std::ptr::null(),
26962             global_priority: QueueGlobalPriorityEXT::default(),
26963         }
26964     }
26965 }
26966 impl DeviceQueueGlobalPriorityCreateInfoEXT {
builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a>26967     pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
26968         DeviceQueueGlobalPriorityCreateInfoEXTBuilder {
26969             inner: DeviceQueueGlobalPriorityCreateInfoEXT::default(),
26970             marker: ::std::marker::PhantomData,
26971         }
26972     }
26973 }
26974 #[repr(transparent)]
26975 pub struct DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
26976     inner: DeviceQueueGlobalPriorityCreateInfoEXT,
26977     marker: ::std::marker::PhantomData<&'a ()>,
26978 }
26979 unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'_> {}
26980 unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXT {}
26981 impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
26982     type Target = DeviceQueueGlobalPriorityCreateInfoEXT;
deref(&self) -> &Self::Target26983     fn deref(&self) -> &Self::Target {
26984         &self.inner
26985     }
26986 }
26987 impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target26988     fn deref_mut(&mut self) -> &mut Self::Target {
26989         &mut self.inner
26990     }
26991 }
26992 impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
global_priority( mut self, global_priority: QueueGlobalPriorityEXT, ) -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a>26993     pub fn global_priority(
26994         mut self,
26995         global_priority: QueueGlobalPriorityEXT,
26996     ) -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
26997         self.inner.global_priority = global_priority;
26998         self
26999     }
27000     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27001     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27002     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceQueueGlobalPriorityCreateInfoEXT27003     pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoEXT {
27004         self.inner
27005     }
27006 }
27007 #[repr(C)]
27008 #[derive(Copy, Clone, Debug)]
27009 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html>"]
27010 pub struct DebugUtilsObjectNameInfoEXT {
27011     pub s_type: StructureType,
27012     pub p_next: *const c_void,
27013     pub object_type: ObjectType,
27014     pub object_handle: u64,
27015     pub p_object_name: *const c_char,
27016 }
27017 impl ::std::default::Default for DebugUtilsObjectNameInfoEXT {
default() -> DebugUtilsObjectNameInfoEXT27018     fn default() -> DebugUtilsObjectNameInfoEXT {
27019         DebugUtilsObjectNameInfoEXT {
27020             s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
27021             p_next: ::std::ptr::null(),
27022             object_type: ObjectType::default(),
27023             object_handle: u64::default(),
27024             p_object_name: ::std::ptr::null(),
27025         }
27026     }
27027 }
27028 impl DebugUtilsObjectNameInfoEXT {
builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a>27029     pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
27030         DebugUtilsObjectNameInfoEXTBuilder {
27031             inner: DebugUtilsObjectNameInfoEXT::default(),
27032             marker: ::std::marker::PhantomData,
27033         }
27034     }
27035 }
27036 #[repr(transparent)]
27037 pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
27038     inner: DebugUtilsObjectNameInfoEXT,
27039     marker: ::std::marker::PhantomData<&'a ()>,
27040 }
27041 pub unsafe trait ExtendsDebugUtilsObjectNameInfoEXT {}
27042 impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
27043     type Target = DebugUtilsObjectNameInfoEXT;
deref(&self) -> &Self::Target27044     fn deref(&self) -> &Self::Target {
27045         &self.inner
27046     }
27047 }
27048 impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27049     fn deref_mut(&mut self) -> &mut Self::Target {
27050         &mut self.inner
27051     }
27052 }
27053 impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
object_type( mut self, object_type: ObjectType, ) -> DebugUtilsObjectNameInfoEXTBuilder<'a>27054     pub fn object_type(
27055         mut self,
27056         object_type: ObjectType,
27057     ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
27058         self.inner.object_type = object_type;
27059         self
27060     }
object_handle(mut self, object_handle: u64) -> DebugUtilsObjectNameInfoEXTBuilder<'a>27061     pub fn object_handle(mut self, object_handle: u64) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
27062         self.inner.object_handle = object_handle;
27063         self
27064     }
object_name( mut self, object_name: &'a ::std::ffi::CStr, ) -> DebugUtilsObjectNameInfoEXTBuilder<'a>27065     pub fn object_name(
27066         mut self,
27067         object_name: &'a ::std::ffi::CStr,
27068     ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
27069         self.inner.p_object_name = object_name.as_ptr();
27070         self
27071     }
27072     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27073     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27074     #[doc = r" valid extension structs can be pushed into the chain."]
27075     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27076     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugUtilsObjectNameInfoEXT>( mut self, next: &'a mut T, ) -> DebugUtilsObjectNameInfoEXTBuilder<'a>27077     pub fn push_next<T: ExtendsDebugUtilsObjectNameInfoEXT>(
27078         mut self,
27079         next: &'a mut T,
27080     ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
27081         unsafe {
27082             let next_ptr = next as *mut T as *mut BaseOutStructure;
27083             let last_next = ptr_chain_iter(next).last().unwrap();
27084             (*last_next).p_next = self.inner.p_next as _;
27085             self.inner.p_next = next_ptr as _;
27086         }
27087         self
27088     }
27089     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27090     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27091     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsObjectNameInfoEXT27092     pub fn build(self) -> DebugUtilsObjectNameInfoEXT {
27093         self.inner
27094     }
27095 }
27096 #[repr(C)]
27097 #[derive(Copy, Clone, Debug)]
27098 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html>"]
27099 pub struct DebugUtilsObjectTagInfoEXT {
27100     pub s_type: StructureType,
27101     pub p_next: *const c_void,
27102     pub object_type: ObjectType,
27103     pub object_handle: u64,
27104     pub tag_name: u64,
27105     pub tag_size: usize,
27106     pub p_tag: *const c_void,
27107 }
27108 impl ::std::default::Default for DebugUtilsObjectTagInfoEXT {
default() -> DebugUtilsObjectTagInfoEXT27109     fn default() -> DebugUtilsObjectTagInfoEXT {
27110         DebugUtilsObjectTagInfoEXT {
27111             s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
27112             p_next: ::std::ptr::null(),
27113             object_type: ObjectType::default(),
27114             object_handle: u64::default(),
27115             tag_name: u64::default(),
27116             tag_size: usize::default(),
27117             p_tag: ::std::ptr::null(),
27118         }
27119     }
27120 }
27121 impl DebugUtilsObjectTagInfoEXT {
builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a>27122     pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
27123         DebugUtilsObjectTagInfoEXTBuilder {
27124             inner: DebugUtilsObjectTagInfoEXT::default(),
27125             marker: ::std::marker::PhantomData,
27126         }
27127     }
27128 }
27129 #[repr(transparent)]
27130 pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> {
27131     inner: DebugUtilsObjectTagInfoEXT,
27132     marker: ::std::marker::PhantomData<&'a ()>,
27133 }
27134 pub unsafe trait ExtendsDebugUtilsObjectTagInfoEXT {}
27135 impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> {
27136     type Target = DebugUtilsObjectTagInfoEXT;
deref(&self) -> &Self::Target27137     fn deref(&self) -> &Self::Target {
27138         &self.inner
27139     }
27140 }
27141 impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27142     fn deref_mut(&mut self) -> &mut Self::Target {
27143         &mut self.inner
27144     }
27145 }
27146 impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
object_type(mut self, object_type: ObjectType) -> DebugUtilsObjectTagInfoEXTBuilder<'a>27147     pub fn object_type(mut self, object_type: ObjectType) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
27148         self.inner.object_type = object_type;
27149         self
27150     }
object_handle(mut self, object_handle: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a>27151     pub fn object_handle(mut self, object_handle: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
27152         self.inner.object_handle = object_handle;
27153         self
27154     }
tag_name(mut self, tag_name: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a>27155     pub fn tag_name(mut self, tag_name: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
27156         self.inner.tag_name = tag_name;
27157         self
27158     }
tag(mut self, tag: &'a [u8]) -> DebugUtilsObjectTagInfoEXTBuilder<'a>27159     pub fn tag(mut self, tag: &'a [u8]) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
27160         self.inner.tag_size = tag.len() as _;
27161         self.inner.p_tag = tag.as_ptr() as *const c_void;
27162         self
27163     }
27164     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27165     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27166     #[doc = r" valid extension structs can be pushed into the chain."]
27167     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27168     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugUtilsObjectTagInfoEXT>( mut self, next: &'a mut T, ) -> DebugUtilsObjectTagInfoEXTBuilder<'a>27169     pub fn push_next<T: ExtendsDebugUtilsObjectTagInfoEXT>(
27170         mut self,
27171         next: &'a mut T,
27172     ) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
27173         unsafe {
27174             let next_ptr = next as *mut T as *mut BaseOutStructure;
27175             let last_next = ptr_chain_iter(next).last().unwrap();
27176             (*last_next).p_next = self.inner.p_next as _;
27177             self.inner.p_next = next_ptr as _;
27178         }
27179         self
27180     }
27181     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27182     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27183     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsObjectTagInfoEXT27184     pub fn build(self) -> DebugUtilsObjectTagInfoEXT {
27185         self.inner
27186     }
27187 }
27188 #[repr(C)]
27189 #[derive(Copy, Clone, Debug)]
27190 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsLabelEXT.html>"]
27191 pub struct DebugUtilsLabelEXT {
27192     pub s_type: StructureType,
27193     pub p_next: *const c_void,
27194     pub p_label_name: *const c_char,
27195     pub color: [f32; 4],
27196 }
27197 impl ::std::default::Default for DebugUtilsLabelEXT {
default() -> DebugUtilsLabelEXT27198     fn default() -> DebugUtilsLabelEXT {
27199         DebugUtilsLabelEXT {
27200             s_type: StructureType::DEBUG_UTILS_LABEL_EXT,
27201             p_next: ::std::ptr::null(),
27202             p_label_name: ::std::ptr::null(),
27203             color: unsafe { ::std::mem::zeroed() },
27204         }
27205     }
27206 }
27207 impl DebugUtilsLabelEXT {
builder<'a>() -> DebugUtilsLabelEXTBuilder<'a>27208     pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> {
27209         DebugUtilsLabelEXTBuilder {
27210             inner: DebugUtilsLabelEXT::default(),
27211             marker: ::std::marker::PhantomData,
27212         }
27213     }
27214 }
27215 #[repr(transparent)]
27216 pub struct DebugUtilsLabelEXTBuilder<'a> {
27217     inner: DebugUtilsLabelEXT,
27218     marker: ::std::marker::PhantomData<&'a ()>,
27219 }
27220 pub unsafe trait ExtendsDebugUtilsLabelEXT {}
27221 impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> {
27222     type Target = DebugUtilsLabelEXT;
deref(&self) -> &Self::Target27223     fn deref(&self) -> &Self::Target {
27224         &self.inner
27225     }
27226 }
27227 impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27228     fn deref_mut(&mut self) -> &mut Self::Target {
27229         &mut self.inner
27230     }
27231 }
27232 impl<'a> DebugUtilsLabelEXTBuilder<'a> {
label_name(mut self, label_name: &'a ::std::ffi::CStr) -> DebugUtilsLabelEXTBuilder<'a>27233     pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> DebugUtilsLabelEXTBuilder<'a> {
27234         self.inner.p_label_name = label_name.as_ptr();
27235         self
27236     }
color(mut self, color: [f32; 4]) -> DebugUtilsLabelEXTBuilder<'a>27237     pub fn color(mut self, color: [f32; 4]) -> DebugUtilsLabelEXTBuilder<'a> {
27238         self.inner.color = color;
27239         self
27240     }
27241     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27242     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27243     #[doc = r" valid extension structs can be pushed into the chain."]
27244     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27245     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugUtilsLabelEXT>( mut self, next: &'a mut T, ) -> DebugUtilsLabelEXTBuilder<'a>27246     pub fn push_next<T: ExtendsDebugUtilsLabelEXT>(
27247         mut self,
27248         next: &'a mut T,
27249     ) -> DebugUtilsLabelEXTBuilder<'a> {
27250         unsafe {
27251             let next_ptr = next as *mut T as *mut BaseOutStructure;
27252             let last_next = ptr_chain_iter(next).last().unwrap();
27253             (*last_next).p_next = self.inner.p_next as _;
27254             self.inner.p_next = next_ptr as _;
27255         }
27256         self
27257     }
27258     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27259     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27260     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsLabelEXT27261     pub fn build(self) -> DebugUtilsLabelEXT {
27262         self.inner
27263     }
27264 }
27265 #[repr(C)]
27266 #[derive(Copy, Clone)]
27267 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>"]
27268 pub struct DebugUtilsMessengerCreateInfoEXT {
27269     pub s_type: StructureType,
27270     pub p_next: *const c_void,
27271     pub flags: DebugUtilsMessengerCreateFlagsEXT,
27272     pub message_severity: DebugUtilsMessageSeverityFlagsEXT,
27273     pub message_type: DebugUtilsMessageTypeFlagsEXT,
27274     pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
27275     pub p_user_data: *mut c_void,
27276 }
27277 impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result27278     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
27279         fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT")
27280             .field("s_type", &self.s_type)
27281             .field("p_next", &self.p_next)
27282             .field("flags", &self.flags)
27283             .field("message_severity", &self.message_severity)
27284             .field("message_type", &self.message_type)
27285             .field(
27286                 "pfn_user_callback",
27287                 &(self.pfn_user_callback.map(|x| x as *const ())),
27288             )
27289             .field("p_user_data", &self.p_user_data)
27290             .finish()
27291     }
27292 }
27293 impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT {
default() -> DebugUtilsMessengerCreateInfoEXT27294     fn default() -> DebugUtilsMessengerCreateInfoEXT {
27295         DebugUtilsMessengerCreateInfoEXT {
27296             s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
27297             p_next: ::std::ptr::null(),
27298             flags: DebugUtilsMessengerCreateFlagsEXT::default(),
27299             message_severity: DebugUtilsMessageSeverityFlagsEXT::default(),
27300             message_type: DebugUtilsMessageTypeFlagsEXT::default(),
27301             pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(),
27302             p_user_data: ::std::ptr::null_mut(),
27303         }
27304     }
27305 }
27306 impl DebugUtilsMessengerCreateInfoEXT {
builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a>27307     pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27308         DebugUtilsMessengerCreateInfoEXTBuilder {
27309             inner: DebugUtilsMessengerCreateInfoEXT::default(),
27310             marker: ::std::marker::PhantomData,
27311         }
27312     }
27313 }
27314 #[repr(transparent)]
27315 pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27316     inner: DebugUtilsMessengerCreateInfoEXT,
27317     marker: ::std::marker::PhantomData<&'a ()>,
27318 }
27319 unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {}
27320 unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {}
27321 impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27322     type Target = DebugUtilsMessengerCreateInfoEXT;
deref(&self) -> &Self::Target27323     fn deref(&self) -> &Self::Target {
27324         &self.inner
27325     }
27326 }
27327 impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27328     fn deref_mut(&mut self) -> &mut Self::Target {
27329         &mut self.inner
27330     }
27331 }
27332 impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
flags( mut self, flags: DebugUtilsMessengerCreateFlagsEXT, ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a>27333     pub fn flags(
27334         mut self,
27335         flags: DebugUtilsMessengerCreateFlagsEXT,
27336     ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27337         self.inner.flags = flags;
27338         self
27339     }
message_severity( mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT, ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a>27340     pub fn message_severity(
27341         mut self,
27342         message_severity: DebugUtilsMessageSeverityFlagsEXT,
27343     ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27344         self.inner.message_severity = message_severity;
27345         self
27346     }
message_type( mut self, message_type: DebugUtilsMessageTypeFlagsEXT, ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a>27347     pub fn message_type(
27348         mut self,
27349         message_type: DebugUtilsMessageTypeFlagsEXT,
27350     ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27351         self.inner.message_type = message_type;
27352         self
27353     }
pfn_user_callback( mut self, pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a>27354     pub fn pfn_user_callback(
27355         mut self,
27356         pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
27357     ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27358         self.inner.pfn_user_callback = pfn_user_callback;
27359         self
27360     }
user_data( mut self, user_data: *mut c_void, ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a>27361     pub fn user_data(
27362         mut self,
27363         user_data: *mut c_void,
27364     ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
27365         self.inner.p_user_data = user_data;
27366         self
27367     }
27368     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27369     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27370     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsMessengerCreateInfoEXT27371     pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT {
27372         self.inner
27373     }
27374 }
27375 #[repr(C)]
27376 #[derive(Copy, Clone, Debug)]
27377 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>"]
27378 pub struct DebugUtilsMessengerCallbackDataEXT {
27379     pub s_type: StructureType,
27380     pub p_next: *const c_void,
27381     pub flags: DebugUtilsMessengerCallbackDataFlagsEXT,
27382     pub p_message_id_name: *const c_char,
27383     pub message_id_number: i32,
27384     pub p_message: *const c_char,
27385     pub queue_label_count: u32,
27386     pub p_queue_labels: *const DebugUtilsLabelEXT,
27387     pub cmd_buf_label_count: u32,
27388     pub p_cmd_buf_labels: *const DebugUtilsLabelEXT,
27389     pub object_count: u32,
27390     pub p_objects: *const DebugUtilsObjectNameInfoEXT,
27391 }
27392 impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT {
default() -> DebugUtilsMessengerCallbackDataEXT27393     fn default() -> DebugUtilsMessengerCallbackDataEXT {
27394         DebugUtilsMessengerCallbackDataEXT {
27395             s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
27396             p_next: ::std::ptr::null(),
27397             flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(),
27398             p_message_id_name: ::std::ptr::null(),
27399             message_id_number: i32::default(),
27400             p_message: ::std::ptr::null(),
27401             queue_label_count: u32::default(),
27402             p_queue_labels: ::std::ptr::null(),
27403             cmd_buf_label_count: u32::default(),
27404             p_cmd_buf_labels: ::std::ptr::null(),
27405             object_count: u32::default(),
27406             p_objects: ::std::ptr::null(),
27407         }
27408     }
27409 }
27410 impl DebugUtilsMessengerCallbackDataEXT {
builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27411     pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27412         DebugUtilsMessengerCallbackDataEXTBuilder {
27413             inner: DebugUtilsMessengerCallbackDataEXT::default(),
27414             marker: ::std::marker::PhantomData,
27415         }
27416     }
27417 }
27418 #[repr(transparent)]
27419 pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27420     inner: DebugUtilsMessengerCallbackDataEXT,
27421     marker: ::std::marker::PhantomData<&'a ()>,
27422 }
27423 pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {}
27424 impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27425     type Target = DebugUtilsMessengerCallbackDataEXT;
deref(&self) -> &Self::Target27426     fn deref(&self) -> &Self::Target {
27427         &self.inner
27428     }
27429 }
27430 impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27431     fn deref_mut(&mut self) -> &mut Self::Target {
27432         &mut self.inner
27433     }
27434 }
27435 impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
flags( mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT, ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27436     pub fn flags(
27437         mut self,
27438         flags: DebugUtilsMessengerCallbackDataFlagsEXT,
27439     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27440         self.inner.flags = flags;
27441         self
27442     }
message_id_name( mut self, message_id_name: &'a ::std::ffi::CStr, ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27443     pub fn message_id_name(
27444         mut self,
27445         message_id_name: &'a ::std::ffi::CStr,
27446     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27447         self.inner.p_message_id_name = message_id_name.as_ptr();
27448         self
27449     }
message_id_number( mut self, message_id_number: i32, ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27450     pub fn message_id_number(
27451         mut self,
27452         message_id_number: i32,
27453     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27454         self.inner.message_id_number = message_id_number;
27455         self
27456     }
message( mut self, message: &'a ::std::ffi::CStr, ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27457     pub fn message(
27458         mut self,
27459         message: &'a ::std::ffi::CStr,
27460     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27461         self.inner.p_message = message.as_ptr();
27462         self
27463     }
queue_labels( mut self, queue_labels: &'a [DebugUtilsLabelEXT], ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27464     pub fn queue_labels(
27465         mut self,
27466         queue_labels: &'a [DebugUtilsLabelEXT],
27467     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27468         self.inner.queue_label_count = queue_labels.len() as _;
27469         self.inner.p_queue_labels = queue_labels.as_ptr();
27470         self
27471     }
cmd_buf_labels( mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT], ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27472     pub fn cmd_buf_labels(
27473         mut self,
27474         cmd_buf_labels: &'a [DebugUtilsLabelEXT],
27475     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27476         self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _;
27477         self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr();
27478         self
27479     }
objects( mut self, objects: &'a [DebugUtilsObjectNameInfoEXT], ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27480     pub fn objects(
27481         mut self,
27482         objects: &'a [DebugUtilsObjectNameInfoEXT],
27483     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27484         self.inner.object_count = objects.len() as _;
27485         self.inner.p_objects = objects.as_ptr();
27486         self
27487     }
27488     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27489     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27490     #[doc = r" valid extension structs can be pushed into the chain."]
27491     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27492     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>( mut self, next: &'a mut T, ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a>27493     pub fn push_next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>(
27494         mut self,
27495         next: &'a mut T,
27496     ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
27497         unsafe {
27498             let next_ptr = next as *mut T as *mut BaseOutStructure;
27499             let last_next = ptr_chain_iter(next).last().unwrap();
27500             (*last_next).p_next = self.inner.p_next as _;
27501             self.inner.p_next = next_ptr as _;
27502         }
27503         self
27504     }
27505     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27506     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27507     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DebugUtilsMessengerCallbackDataEXT27508     pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT {
27509         self.inner
27510     }
27511 }
27512 #[repr(C)]
27513 #[derive(Copy, Clone, Debug)]
27514 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html>"]
27515 pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT {
27516     pub s_type: StructureType,
27517     pub p_next: *mut c_void,
27518     pub device_memory_report: Bool32,
27519 }
27520 impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
default() -> PhysicalDeviceDeviceMemoryReportFeaturesEXT27521     fn default() -> PhysicalDeviceDeviceMemoryReportFeaturesEXT {
27522         PhysicalDeviceDeviceMemoryReportFeaturesEXT {
27523             s_type: StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
27524             p_next: ::std::ptr::null_mut(),
27525             device_memory_report: Bool32::default(),
27526         }
27527     }
27528 }
27529 impl PhysicalDeviceDeviceMemoryReportFeaturesEXT {
builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a>27530     pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
27531         PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder {
27532             inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT::default(),
27533             marker: ::std::marker::PhantomData,
27534         }
27535     }
27536 }
27537 #[repr(transparent)]
27538 pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
27539     inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT,
27540     marker: ::std::marker::PhantomData<&'a ()>,
27541 }
27542 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {}
27543 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {}
27544 impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
27545     type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
deref(&self) -> &Self::Target27546     fn deref(&self) -> &Self::Target {
27547         &self.inner
27548     }
27549 }
27550 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27551     fn deref_mut(&mut self) -> &mut Self::Target {
27552         &mut self.inner
27553     }
27554 }
27555 impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
device_memory_report( mut self, device_memory_report: bool, ) -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a>27556     pub fn device_memory_report(
27557         mut self,
27558         device_memory_report: bool,
27559     ) -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
27560         self.inner.device_memory_report = device_memory_report.into();
27561         self
27562     }
27563     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27564     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27565     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT27566     pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT {
27567         self.inner
27568     }
27569 }
27570 #[repr(C)]
27571 #[derive(Copy, Clone)]
27572 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html>"]
27573 pub struct DeviceDeviceMemoryReportCreateInfoEXT {
27574     pub s_type: StructureType,
27575     pub p_next: *const c_void,
27576     pub flags: DeviceMemoryReportFlagsEXT,
27577     pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
27578     pub p_user_data: *mut c_void,
27579 }
27580 impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result27581     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
27582         fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT")
27583             .field("s_type", &self.s_type)
27584             .field("p_next", &self.p_next)
27585             .field("flags", &self.flags)
27586             .field(
27587                 "pfn_user_callback",
27588                 &(self.pfn_user_callback.map(|x| x as *const ())),
27589             )
27590             .field("p_user_data", &self.p_user_data)
27591             .finish()
27592     }
27593 }
27594 impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT {
default() -> DeviceDeviceMemoryReportCreateInfoEXT27595     fn default() -> DeviceDeviceMemoryReportCreateInfoEXT {
27596         DeviceDeviceMemoryReportCreateInfoEXT {
27597             s_type: StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
27598             p_next: ::std::ptr::null(),
27599             flags: DeviceMemoryReportFlagsEXT::default(),
27600             pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(),
27601             p_user_data: ::std::ptr::null_mut(),
27602         }
27603     }
27604 }
27605 impl DeviceDeviceMemoryReportCreateInfoEXT {
builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a>27606     pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
27607         DeviceDeviceMemoryReportCreateInfoEXTBuilder {
27608             inner: DeviceDeviceMemoryReportCreateInfoEXT::default(),
27609             marker: ::std::marker::PhantomData,
27610         }
27611     }
27612 }
27613 #[repr(transparent)]
27614 pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
27615     inner: DeviceDeviceMemoryReportCreateInfoEXT,
27616     marker: ::std::marker::PhantomData<&'a ()>,
27617 }
27618 unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {}
27619 unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {}
27620 impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
27621     type Target = DeviceDeviceMemoryReportCreateInfoEXT;
deref(&self) -> &Self::Target27622     fn deref(&self) -> &Self::Target {
27623         &self.inner
27624     }
27625 }
27626 impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27627     fn deref_mut(&mut self) -> &mut Self::Target {
27628         &mut self.inner
27629     }
27630 }
27631 impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
flags( mut self, flags: DeviceMemoryReportFlagsEXT, ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a>27632     pub fn flags(
27633         mut self,
27634         flags: DeviceMemoryReportFlagsEXT,
27635     ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
27636         self.inner.flags = flags;
27637         self
27638     }
pfn_user_callback( mut self, pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a>27639     pub fn pfn_user_callback(
27640         mut self,
27641         pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
27642     ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
27643         self.inner.pfn_user_callback = pfn_user_callback;
27644         self
27645     }
user_data( mut self, user_data: *mut c_void, ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a>27646     pub fn user_data(
27647         mut self,
27648         user_data: *mut c_void,
27649     ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
27650         self.inner.p_user_data = user_data;
27651         self
27652     }
27653     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27654     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27655     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceDeviceMemoryReportCreateInfoEXT27656     pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT {
27657         self.inner
27658     }
27659 }
27660 #[repr(C)]
27661 #[derive(Copy, Clone, Debug)]
27662 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryReportCallbackDataEXT.html>"]
27663 pub struct DeviceMemoryReportCallbackDataEXT {
27664     pub s_type: StructureType,
27665     pub p_next: *const c_void,
27666     pub flags: DeviceMemoryReportFlagsEXT,
27667     pub ty: DeviceMemoryReportEventTypeEXT,
27668     pub memory_object_id: u64,
27669     pub size: DeviceSize,
27670     pub object_type: ObjectType,
27671     pub object_handle: u64,
27672     pub heap_index: u32,
27673 }
27674 impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT {
default() -> DeviceMemoryReportCallbackDataEXT27675     fn default() -> DeviceMemoryReportCallbackDataEXT {
27676         DeviceMemoryReportCallbackDataEXT {
27677             s_type: StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
27678             p_next: ::std::ptr::null(),
27679             flags: DeviceMemoryReportFlagsEXT::default(),
27680             ty: DeviceMemoryReportEventTypeEXT::default(),
27681             memory_object_id: u64::default(),
27682             size: DeviceSize::default(),
27683             object_type: ObjectType::default(),
27684             object_handle: u64::default(),
27685             heap_index: u32::default(),
27686         }
27687     }
27688 }
27689 impl DeviceMemoryReportCallbackDataEXT {
builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27690     pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27691         DeviceMemoryReportCallbackDataEXTBuilder {
27692             inner: DeviceMemoryReportCallbackDataEXT::default(),
27693             marker: ::std::marker::PhantomData,
27694         }
27695     }
27696 }
27697 #[repr(transparent)]
27698 pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27699     inner: DeviceMemoryReportCallbackDataEXT,
27700     marker: ::std::marker::PhantomData<&'a ()>,
27701 }
27702 pub unsafe trait ExtendsDeviceMemoryReportCallbackDataEXT {}
27703 impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27704     type Target = DeviceMemoryReportCallbackDataEXT;
deref(&self) -> &Self::Target27705     fn deref(&self) -> &Self::Target {
27706         &self.inner
27707     }
27708 }
27709 impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27710     fn deref_mut(&mut self) -> &mut Self::Target {
27711         &mut self.inner
27712     }
27713 }
27714 impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
flags( mut self, flags: DeviceMemoryReportFlagsEXT, ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27715     pub fn flags(
27716         mut self,
27717         flags: DeviceMemoryReportFlagsEXT,
27718     ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27719         self.inner.flags = flags;
27720         self
27721     }
ty( mut self, ty: DeviceMemoryReportEventTypeEXT, ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27722     pub fn ty(
27723         mut self,
27724         ty: DeviceMemoryReportEventTypeEXT,
27725     ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27726         self.inner.ty = ty;
27727         self
27728     }
memory_object_id( mut self, memory_object_id: u64, ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27729     pub fn memory_object_id(
27730         mut self,
27731         memory_object_id: u64,
27732     ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27733         self.inner.memory_object_id = memory_object_id;
27734         self
27735     }
size(mut self, size: DeviceSize) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27736     pub fn size(mut self, size: DeviceSize) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27737         self.inner.size = size;
27738         self
27739     }
object_type( mut self, object_type: ObjectType, ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27740     pub fn object_type(
27741         mut self,
27742         object_type: ObjectType,
27743     ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27744         self.inner.object_type = object_type;
27745         self
27746     }
object_handle( mut self, object_handle: u64, ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27747     pub fn object_handle(
27748         mut self,
27749         object_handle: u64,
27750     ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27751         self.inner.object_handle = object_handle;
27752         self
27753     }
heap_index(mut self, heap_index: u32) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27754     pub fn heap_index(mut self, heap_index: u32) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27755         self.inner.heap_index = heap_index;
27756         self
27757     }
27758     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27759     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27760     #[doc = r" valid extension structs can be pushed into the chain."]
27761     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27762     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceMemoryReportCallbackDataEXT>( mut self, next: &'a mut T, ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a>27763     pub fn push_next<T: ExtendsDeviceMemoryReportCallbackDataEXT>(
27764         mut self,
27765         next: &'a mut T,
27766     ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
27767         unsafe {
27768             let next_ptr = next as *mut T as *mut BaseOutStructure;
27769             let last_next = ptr_chain_iter(next).last().unwrap();
27770             (*last_next).p_next = self.inner.p_next as _;
27771             self.inner.p_next = next_ptr as _;
27772         }
27773         self
27774     }
27775     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27776     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27777     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceMemoryReportCallbackDataEXT27778     pub fn build(self) -> DeviceMemoryReportCallbackDataEXT {
27779         self.inner
27780     }
27781 }
27782 #[repr(C)]
27783 #[derive(Copy, Clone, Debug)]
27784 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html>"]
27785 pub struct ImportMemoryHostPointerInfoEXT {
27786     pub s_type: StructureType,
27787     pub p_next: *const c_void,
27788     pub handle_type: ExternalMemoryHandleTypeFlags,
27789     pub p_host_pointer: *mut c_void,
27790 }
27791 impl ::std::default::Default for ImportMemoryHostPointerInfoEXT {
default() -> ImportMemoryHostPointerInfoEXT27792     fn default() -> ImportMemoryHostPointerInfoEXT {
27793         ImportMemoryHostPointerInfoEXT {
27794             s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
27795             p_next: ::std::ptr::null(),
27796             handle_type: ExternalMemoryHandleTypeFlags::default(),
27797             p_host_pointer: ::std::ptr::null_mut(),
27798         }
27799     }
27800 }
27801 impl ImportMemoryHostPointerInfoEXT {
builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a>27802     pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
27803         ImportMemoryHostPointerInfoEXTBuilder {
27804             inner: ImportMemoryHostPointerInfoEXT::default(),
27805             marker: ::std::marker::PhantomData,
27806         }
27807     }
27808 }
27809 #[repr(transparent)]
27810 pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> {
27811     inner: ImportMemoryHostPointerInfoEXT,
27812     marker: ::std::marker::PhantomData<&'a ()>,
27813 }
27814 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {}
27815 unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {}
27816 impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> {
27817     type Target = ImportMemoryHostPointerInfoEXT;
deref(&self) -> &Self::Target27818     fn deref(&self) -> &Self::Target {
27819         &self.inner
27820     }
27821 }
27822 impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27823     fn deref_mut(&mut self) -> &mut Self::Target {
27824         &mut self.inner
27825     }
27826 }
27827 impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
handle_type( mut self, handle_type: ExternalMemoryHandleTypeFlags, ) -> ImportMemoryHostPointerInfoEXTBuilder<'a>27828     pub fn handle_type(
27829         mut self,
27830         handle_type: ExternalMemoryHandleTypeFlags,
27831     ) -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
27832         self.inner.handle_type = handle_type;
27833         self
27834     }
host_pointer( mut self, host_pointer: *mut c_void, ) -> ImportMemoryHostPointerInfoEXTBuilder<'a>27835     pub fn host_pointer(
27836         mut self,
27837         host_pointer: *mut c_void,
27838     ) -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
27839         self.inner.p_host_pointer = host_pointer;
27840         self
27841     }
27842     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27843     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27844     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportMemoryHostPointerInfoEXT27845     pub fn build(self) -> ImportMemoryHostPointerInfoEXT {
27846         self.inner
27847     }
27848 }
27849 #[repr(C)]
27850 #[derive(Copy, Clone, Debug)]
27851 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html>"]
27852 pub struct MemoryHostPointerPropertiesEXT {
27853     pub s_type: StructureType,
27854     pub p_next: *mut c_void,
27855     pub memory_type_bits: u32,
27856 }
27857 impl ::std::default::Default for MemoryHostPointerPropertiesEXT {
default() -> MemoryHostPointerPropertiesEXT27858     fn default() -> MemoryHostPointerPropertiesEXT {
27859         MemoryHostPointerPropertiesEXT {
27860             s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT,
27861             p_next: ::std::ptr::null_mut(),
27862             memory_type_bits: u32::default(),
27863         }
27864     }
27865 }
27866 impl MemoryHostPointerPropertiesEXT {
builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a>27867     pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> {
27868         MemoryHostPointerPropertiesEXTBuilder {
27869             inner: MemoryHostPointerPropertiesEXT::default(),
27870             marker: ::std::marker::PhantomData,
27871         }
27872     }
27873 }
27874 #[repr(transparent)]
27875 pub struct MemoryHostPointerPropertiesEXTBuilder<'a> {
27876     inner: MemoryHostPointerPropertiesEXT,
27877     marker: ::std::marker::PhantomData<&'a ()>,
27878 }
27879 pub unsafe trait ExtendsMemoryHostPointerPropertiesEXT {}
27880 impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> {
27881     type Target = MemoryHostPointerPropertiesEXT;
deref(&self) -> &Self::Target27882     fn deref(&self) -> &Self::Target {
27883         &self.inner
27884     }
27885 }
27886 impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27887     fn deref_mut(&mut self) -> &mut Self::Target {
27888         &mut self.inner
27889     }
27890 }
27891 impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
memory_type_bits( mut self, memory_type_bits: u32, ) -> MemoryHostPointerPropertiesEXTBuilder<'a>27892     pub fn memory_type_bits(
27893         mut self,
27894         memory_type_bits: u32,
27895     ) -> MemoryHostPointerPropertiesEXTBuilder<'a> {
27896         self.inner.memory_type_bits = memory_type_bits;
27897         self
27898     }
27899     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
27900     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
27901     #[doc = r" valid extension structs can be pushed into the chain."]
27902     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
27903     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryHostPointerPropertiesEXT>( mut self, next: &'a mut T, ) -> MemoryHostPointerPropertiesEXTBuilder<'a>27904     pub fn push_next<T: ExtendsMemoryHostPointerPropertiesEXT>(
27905         mut self,
27906         next: &'a mut T,
27907     ) -> MemoryHostPointerPropertiesEXTBuilder<'a> {
27908         unsafe {
27909             let next_ptr = next as *mut T as *mut BaseOutStructure;
27910             let last_next = ptr_chain_iter(next).last().unwrap();
27911             (*last_next).p_next = self.inner.p_next as _;
27912             self.inner.p_next = next_ptr as _;
27913         }
27914         self
27915     }
27916     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27917     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27918     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryHostPointerPropertiesEXT27919     pub fn build(self) -> MemoryHostPointerPropertiesEXT {
27920         self.inner
27921     }
27922 }
27923 #[repr(C)]
27924 #[derive(Copy, Clone, Debug)]
27925 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>"]
27926 pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
27927     pub s_type: StructureType,
27928     pub p_next: *mut c_void,
27929     pub min_imported_host_pointer_alignment: DeviceSize,
27930 }
27931 impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT {
default() -> PhysicalDeviceExternalMemoryHostPropertiesEXT27932     fn default() -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
27933         PhysicalDeviceExternalMemoryHostPropertiesEXT {
27934             s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
27935             p_next: ::std::ptr::null_mut(),
27936             min_imported_host_pointer_alignment: DeviceSize::default(),
27937         }
27938     }
27939 }
27940 impl PhysicalDeviceExternalMemoryHostPropertiesEXT {
builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a>27941     pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
27942         PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder {
27943             inner: PhysicalDeviceExternalMemoryHostPropertiesEXT::default(),
27944             marker: ::std::marker::PhantomData,
27945         }
27946     }
27947 }
27948 #[repr(transparent)]
27949 pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
27950     inner: PhysicalDeviceExternalMemoryHostPropertiesEXT,
27951     marker: ::std::marker::PhantomData<&'a ()>,
27952 }
27953 unsafe impl ExtendsPhysicalDeviceProperties2
27954     for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_>
27955 {
27956 }
27957 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {}
27958 impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
27959     type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT;
deref(&self) -> &Self::Target27960     fn deref(&self) -> &Self::Target {
27961         &self.inner
27962     }
27963 }
27964 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target27965     fn deref_mut(&mut self) -> &mut Self::Target {
27966         &mut self.inner
27967     }
27968 }
27969 impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
min_imported_host_pointer_alignment( mut self, min_imported_host_pointer_alignment: DeviceSize, ) -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a>27970     pub fn min_imported_host_pointer_alignment(
27971         mut self,
27972         min_imported_host_pointer_alignment: DeviceSize,
27973     ) -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
27974         self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment;
27975         self
27976     }
27977     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
27978     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
27979     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT27980     pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
27981         self.inner
27982     }
27983 }
27984 #[repr(C)]
27985 #[derive(Copy, Clone, Debug)]
27986 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>"]
27987 pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
27988     pub s_type: StructureType,
27989     pub p_next: *mut c_void,
27990     pub primitive_overestimation_size: f32,
27991     pub max_extra_primitive_overestimation_size: f32,
27992     pub extra_primitive_overestimation_size_granularity: f32,
27993     pub primitive_underestimation: Bool32,
27994     pub conservative_point_and_line_rasterization: Bool32,
27995     pub degenerate_triangles_rasterized: Bool32,
27996     pub degenerate_lines_rasterized: Bool32,
27997     pub fully_covered_fragment_shader_input_variable: Bool32,
27998     pub conservative_rasterization_post_depth_coverage: Bool32,
27999 }
28000 impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
default() -> PhysicalDeviceConservativeRasterizationPropertiesEXT28001     fn default() -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
28002         PhysicalDeviceConservativeRasterizationPropertiesEXT {
28003             s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
28004             p_next: ::std::ptr::null_mut(),
28005             primitive_overestimation_size: f32::default(),
28006             max_extra_primitive_overestimation_size: f32::default(),
28007             extra_primitive_overestimation_size_granularity: f32::default(),
28008             primitive_underestimation: Bool32::default(),
28009             conservative_point_and_line_rasterization: Bool32::default(),
28010             degenerate_triangles_rasterized: Bool32::default(),
28011             degenerate_lines_rasterized: Bool32::default(),
28012             fully_covered_fragment_shader_input_variable: Bool32::default(),
28013             conservative_rasterization_post_depth_coverage: Bool32::default(),
28014         }
28015     }
28016 }
28017 impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28018     pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28019         PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder {
28020             inner: PhysicalDeviceConservativeRasterizationPropertiesEXT::default(),
28021             marker: ::std::marker::PhantomData,
28022         }
28023     }
28024 }
28025 #[repr(transparent)]
28026 pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28027     inner: PhysicalDeviceConservativeRasterizationPropertiesEXT,
28028     marker: ::std::marker::PhantomData<&'a ()>,
28029 }
28030 unsafe impl ExtendsPhysicalDeviceProperties2
28031     for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_>
28032 {
28033 }
28034 unsafe impl ExtendsPhysicalDeviceProperties2
28035     for PhysicalDeviceConservativeRasterizationPropertiesEXT
28036 {
28037 }
28038 impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28039     type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT;
deref(&self) -> &Self::Target28040     fn deref(&self) -> &Self::Target {
28041         &self.inner
28042     }
28043 }
28044 impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28045     fn deref_mut(&mut self) -> &mut Self::Target {
28046         &mut self.inner
28047     }
28048 }
28049 impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
primitive_overestimation_size( mut self, primitive_overestimation_size: f32, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28050     pub fn primitive_overestimation_size(
28051         mut self,
28052         primitive_overestimation_size: f32,
28053     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28054         self.inner.primitive_overestimation_size = primitive_overestimation_size;
28055         self
28056     }
max_extra_primitive_overestimation_size( mut self, max_extra_primitive_overestimation_size: f32, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28057     pub fn max_extra_primitive_overestimation_size(
28058         mut self,
28059         max_extra_primitive_overestimation_size: f32,
28060     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28061         self.inner.max_extra_primitive_overestimation_size =
28062             max_extra_primitive_overestimation_size;
28063         self
28064     }
extra_primitive_overestimation_size_granularity( mut self, extra_primitive_overestimation_size_granularity: f32, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28065     pub fn extra_primitive_overestimation_size_granularity(
28066         mut self,
28067         extra_primitive_overestimation_size_granularity: f32,
28068     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28069         self.inner.extra_primitive_overestimation_size_granularity =
28070             extra_primitive_overestimation_size_granularity;
28071         self
28072     }
primitive_underestimation( mut self, primitive_underestimation: bool, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28073     pub fn primitive_underestimation(
28074         mut self,
28075         primitive_underestimation: bool,
28076     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28077         self.inner.primitive_underestimation = primitive_underestimation.into();
28078         self
28079     }
conservative_point_and_line_rasterization( mut self, conservative_point_and_line_rasterization: bool, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28080     pub fn conservative_point_and_line_rasterization(
28081         mut self,
28082         conservative_point_and_line_rasterization: bool,
28083     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28084         self.inner.conservative_point_and_line_rasterization =
28085             conservative_point_and_line_rasterization.into();
28086         self
28087     }
degenerate_triangles_rasterized( mut self, degenerate_triangles_rasterized: bool, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28088     pub fn degenerate_triangles_rasterized(
28089         mut self,
28090         degenerate_triangles_rasterized: bool,
28091     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28092         self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into();
28093         self
28094     }
degenerate_lines_rasterized( mut self, degenerate_lines_rasterized: bool, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28095     pub fn degenerate_lines_rasterized(
28096         mut self,
28097         degenerate_lines_rasterized: bool,
28098     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28099         self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into();
28100         self
28101     }
fully_covered_fragment_shader_input_variable( mut self, fully_covered_fragment_shader_input_variable: bool, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28102     pub fn fully_covered_fragment_shader_input_variable(
28103         mut self,
28104         fully_covered_fragment_shader_input_variable: bool,
28105     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28106         self.inner.fully_covered_fragment_shader_input_variable =
28107             fully_covered_fragment_shader_input_variable.into();
28108         self
28109     }
conservative_rasterization_post_depth_coverage( mut self, conservative_rasterization_post_depth_coverage: bool, ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a>28110     pub fn conservative_rasterization_post_depth_coverage(
28111         mut self,
28112         conservative_rasterization_post_depth_coverage: bool,
28113     ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
28114         self.inner.conservative_rasterization_post_depth_coverage =
28115             conservative_rasterization_post_depth_coverage.into();
28116         self
28117     }
28118     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28119     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28120     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT28121     pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
28122         self.inner
28123     }
28124 }
28125 #[repr(C)]
28126 #[derive(Copy, Clone, Debug)]
28127 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCalibratedTimestampInfoEXT.html>"]
28128 pub struct CalibratedTimestampInfoEXT {
28129     pub s_type: StructureType,
28130     pub p_next: *const c_void,
28131     pub time_domain: TimeDomainEXT,
28132 }
28133 impl ::std::default::Default for CalibratedTimestampInfoEXT {
default() -> CalibratedTimestampInfoEXT28134     fn default() -> CalibratedTimestampInfoEXT {
28135         CalibratedTimestampInfoEXT {
28136             s_type: StructureType::CALIBRATED_TIMESTAMP_INFO_EXT,
28137             p_next: ::std::ptr::null(),
28138             time_domain: TimeDomainEXT::default(),
28139         }
28140     }
28141 }
28142 impl CalibratedTimestampInfoEXT {
builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a>28143     pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> {
28144         CalibratedTimestampInfoEXTBuilder {
28145             inner: CalibratedTimestampInfoEXT::default(),
28146             marker: ::std::marker::PhantomData,
28147         }
28148     }
28149 }
28150 #[repr(transparent)]
28151 pub struct CalibratedTimestampInfoEXTBuilder<'a> {
28152     inner: CalibratedTimestampInfoEXT,
28153     marker: ::std::marker::PhantomData<&'a ()>,
28154 }
28155 pub unsafe trait ExtendsCalibratedTimestampInfoEXT {}
28156 impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> {
28157     type Target = CalibratedTimestampInfoEXT;
deref(&self) -> &Self::Target28158     fn deref(&self) -> &Self::Target {
28159         &self.inner
28160     }
28161 }
28162 impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28163     fn deref_mut(&mut self) -> &mut Self::Target {
28164         &mut self.inner
28165     }
28166 }
28167 impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
time_domain( mut self, time_domain: TimeDomainEXT, ) -> CalibratedTimestampInfoEXTBuilder<'a>28168     pub fn time_domain(
28169         mut self,
28170         time_domain: TimeDomainEXT,
28171     ) -> CalibratedTimestampInfoEXTBuilder<'a> {
28172         self.inner.time_domain = time_domain;
28173         self
28174     }
28175     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
28176     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
28177     #[doc = r" valid extension structs can be pushed into the chain."]
28178     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
28179     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCalibratedTimestampInfoEXT>( mut self, next: &'a mut T, ) -> CalibratedTimestampInfoEXTBuilder<'a>28180     pub fn push_next<T: ExtendsCalibratedTimestampInfoEXT>(
28181         mut self,
28182         next: &'a mut T,
28183     ) -> CalibratedTimestampInfoEXTBuilder<'a> {
28184         unsafe {
28185             let next_ptr = next as *mut T as *mut BaseOutStructure;
28186             let last_next = ptr_chain_iter(next).last().unwrap();
28187             (*last_next).p_next = self.inner.p_next as _;
28188             self.inner.p_next = next_ptr as _;
28189         }
28190         self
28191     }
28192     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28193     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28194     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CalibratedTimestampInfoEXT28195     pub fn build(self) -> CalibratedTimestampInfoEXT {
28196         self.inner
28197     }
28198 }
28199 #[repr(C)]
28200 #[derive(Copy, Clone, Debug)]
28201 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>"]
28202 pub struct PhysicalDeviceShaderCorePropertiesAMD {
28203     pub s_type: StructureType,
28204     pub p_next: *mut c_void,
28205     pub shader_engine_count: u32,
28206     pub shader_arrays_per_engine_count: u32,
28207     pub compute_units_per_shader_array: u32,
28208     pub simd_per_compute_unit: u32,
28209     pub wavefronts_per_simd: u32,
28210     pub wavefront_size: u32,
28211     pub sgprs_per_simd: u32,
28212     pub min_sgpr_allocation: u32,
28213     pub max_sgpr_allocation: u32,
28214     pub sgpr_allocation_granularity: u32,
28215     pub vgprs_per_simd: u32,
28216     pub min_vgpr_allocation: u32,
28217     pub max_vgpr_allocation: u32,
28218     pub vgpr_allocation_granularity: u32,
28219 }
28220 impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD {
default() -> PhysicalDeviceShaderCorePropertiesAMD28221     fn default() -> PhysicalDeviceShaderCorePropertiesAMD {
28222         PhysicalDeviceShaderCorePropertiesAMD {
28223             s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
28224             p_next: ::std::ptr::null_mut(),
28225             shader_engine_count: u32::default(),
28226             shader_arrays_per_engine_count: u32::default(),
28227             compute_units_per_shader_array: u32::default(),
28228             simd_per_compute_unit: u32::default(),
28229             wavefronts_per_simd: u32::default(),
28230             wavefront_size: u32::default(),
28231             sgprs_per_simd: u32::default(),
28232             min_sgpr_allocation: u32::default(),
28233             max_sgpr_allocation: u32::default(),
28234             sgpr_allocation_granularity: u32::default(),
28235             vgprs_per_simd: u32::default(),
28236             min_vgpr_allocation: u32::default(),
28237             max_vgpr_allocation: u32::default(),
28238             vgpr_allocation_granularity: u32::default(),
28239         }
28240     }
28241 }
28242 impl PhysicalDeviceShaderCorePropertiesAMD {
builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28243     pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28244         PhysicalDeviceShaderCorePropertiesAMDBuilder {
28245             inner: PhysicalDeviceShaderCorePropertiesAMD::default(),
28246             marker: ::std::marker::PhantomData,
28247         }
28248     }
28249 }
28250 #[repr(transparent)]
28251 pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28252     inner: PhysicalDeviceShaderCorePropertiesAMD,
28253     marker: ::std::marker::PhantomData<&'a ()>,
28254 }
28255 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {}
28256 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {}
28257 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28258     type Target = PhysicalDeviceShaderCorePropertiesAMD;
deref(&self) -> &Self::Target28259     fn deref(&self) -> &Self::Target {
28260         &self.inner
28261     }
28262 }
28263 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28264     fn deref_mut(&mut self) -> &mut Self::Target {
28265         &mut self.inner
28266     }
28267 }
28268 impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
shader_engine_count( mut self, shader_engine_count: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28269     pub fn shader_engine_count(
28270         mut self,
28271         shader_engine_count: u32,
28272     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28273         self.inner.shader_engine_count = shader_engine_count;
28274         self
28275     }
shader_arrays_per_engine_count( mut self, shader_arrays_per_engine_count: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28276     pub fn shader_arrays_per_engine_count(
28277         mut self,
28278         shader_arrays_per_engine_count: u32,
28279     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28280         self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count;
28281         self
28282     }
compute_units_per_shader_array( mut self, compute_units_per_shader_array: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28283     pub fn compute_units_per_shader_array(
28284         mut self,
28285         compute_units_per_shader_array: u32,
28286     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28287         self.inner.compute_units_per_shader_array = compute_units_per_shader_array;
28288         self
28289     }
simd_per_compute_unit( mut self, simd_per_compute_unit: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28290     pub fn simd_per_compute_unit(
28291         mut self,
28292         simd_per_compute_unit: u32,
28293     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28294         self.inner.simd_per_compute_unit = simd_per_compute_unit;
28295         self
28296     }
wavefronts_per_simd( mut self, wavefronts_per_simd: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28297     pub fn wavefronts_per_simd(
28298         mut self,
28299         wavefronts_per_simd: u32,
28300     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28301         self.inner.wavefronts_per_simd = wavefronts_per_simd;
28302         self
28303     }
wavefront_size( mut self, wavefront_size: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28304     pub fn wavefront_size(
28305         mut self,
28306         wavefront_size: u32,
28307     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28308         self.inner.wavefront_size = wavefront_size;
28309         self
28310     }
sgprs_per_simd( mut self, sgprs_per_simd: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28311     pub fn sgprs_per_simd(
28312         mut self,
28313         sgprs_per_simd: u32,
28314     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28315         self.inner.sgprs_per_simd = sgprs_per_simd;
28316         self
28317     }
min_sgpr_allocation( mut self, min_sgpr_allocation: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28318     pub fn min_sgpr_allocation(
28319         mut self,
28320         min_sgpr_allocation: u32,
28321     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28322         self.inner.min_sgpr_allocation = min_sgpr_allocation;
28323         self
28324     }
max_sgpr_allocation( mut self, max_sgpr_allocation: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28325     pub fn max_sgpr_allocation(
28326         mut self,
28327         max_sgpr_allocation: u32,
28328     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28329         self.inner.max_sgpr_allocation = max_sgpr_allocation;
28330         self
28331     }
sgpr_allocation_granularity( mut self, sgpr_allocation_granularity: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28332     pub fn sgpr_allocation_granularity(
28333         mut self,
28334         sgpr_allocation_granularity: u32,
28335     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28336         self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity;
28337         self
28338     }
vgprs_per_simd( mut self, vgprs_per_simd: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28339     pub fn vgprs_per_simd(
28340         mut self,
28341         vgprs_per_simd: u32,
28342     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28343         self.inner.vgprs_per_simd = vgprs_per_simd;
28344         self
28345     }
min_vgpr_allocation( mut self, min_vgpr_allocation: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28346     pub fn min_vgpr_allocation(
28347         mut self,
28348         min_vgpr_allocation: u32,
28349     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28350         self.inner.min_vgpr_allocation = min_vgpr_allocation;
28351         self
28352     }
max_vgpr_allocation( mut self, max_vgpr_allocation: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28353     pub fn max_vgpr_allocation(
28354         mut self,
28355         max_vgpr_allocation: u32,
28356     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28357         self.inner.max_vgpr_allocation = max_vgpr_allocation;
28358         self
28359     }
vgpr_allocation_granularity( mut self, vgpr_allocation_granularity: u32, ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a>28360     pub fn vgpr_allocation_granularity(
28361         mut self,
28362         vgpr_allocation_granularity: u32,
28363     ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
28364         self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity;
28365         self
28366     }
28367     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28368     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28369     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderCorePropertiesAMD28370     pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD {
28371         self.inner
28372     }
28373 }
28374 #[repr(C)]
28375 #[derive(Copy, Clone, Debug)]
28376 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>"]
28377 pub struct PhysicalDeviceShaderCoreProperties2AMD {
28378     pub s_type: StructureType,
28379     pub p_next: *mut c_void,
28380     pub shader_core_features: ShaderCorePropertiesFlagsAMD,
28381     pub active_compute_unit_count: u32,
28382 }
28383 impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD {
default() -> PhysicalDeviceShaderCoreProperties2AMD28384     fn default() -> PhysicalDeviceShaderCoreProperties2AMD {
28385         PhysicalDeviceShaderCoreProperties2AMD {
28386             s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
28387             p_next: ::std::ptr::null_mut(),
28388             shader_core_features: ShaderCorePropertiesFlagsAMD::default(),
28389             active_compute_unit_count: u32::default(),
28390         }
28391     }
28392 }
28393 impl PhysicalDeviceShaderCoreProperties2AMD {
builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a>28394     pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
28395         PhysicalDeviceShaderCoreProperties2AMDBuilder {
28396             inner: PhysicalDeviceShaderCoreProperties2AMD::default(),
28397             marker: ::std::marker::PhantomData,
28398         }
28399     }
28400 }
28401 #[repr(transparent)]
28402 pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
28403     inner: PhysicalDeviceShaderCoreProperties2AMD,
28404     marker: ::std::marker::PhantomData<&'a ()>,
28405 }
28406 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {}
28407 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {}
28408 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
28409     type Target = PhysicalDeviceShaderCoreProperties2AMD;
deref(&self) -> &Self::Target28410     fn deref(&self) -> &Self::Target {
28411         &self.inner
28412     }
28413 }
28414 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28415     fn deref_mut(&mut self) -> &mut Self::Target {
28416         &mut self.inner
28417     }
28418 }
28419 impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
shader_core_features( mut self, shader_core_features: ShaderCorePropertiesFlagsAMD, ) -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a>28420     pub fn shader_core_features(
28421         mut self,
28422         shader_core_features: ShaderCorePropertiesFlagsAMD,
28423     ) -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
28424         self.inner.shader_core_features = shader_core_features;
28425         self
28426     }
active_compute_unit_count( mut self, active_compute_unit_count: u32, ) -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a>28427     pub fn active_compute_unit_count(
28428         mut self,
28429         active_compute_unit_count: u32,
28430     ) -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
28431         self.inner.active_compute_unit_count = active_compute_unit_count;
28432         self
28433     }
28434     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28435     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28436     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderCoreProperties2AMD28437     pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD {
28438         self.inner
28439     }
28440 }
28441 #[repr(C)]
28442 #[derive(Copy, Clone, Debug)]
28443 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>"]
28444 pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
28445     pub s_type: StructureType,
28446     pub p_next: *const c_void,
28447     pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
28448     pub conservative_rasterization_mode: ConservativeRasterizationModeEXT,
28449     pub extra_primitive_overestimation_size: f32,
28450 }
28451 impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT {
default() -> PipelineRasterizationConservativeStateCreateInfoEXT28452     fn default() -> PipelineRasterizationConservativeStateCreateInfoEXT {
28453         PipelineRasterizationConservativeStateCreateInfoEXT {
28454             s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
28455             p_next: ::std::ptr::null(),
28456             flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(),
28457             conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(),
28458             extra_primitive_overestimation_size: f32::default(),
28459         }
28460     }
28461 }
28462 impl PipelineRasterizationConservativeStateCreateInfoEXT {
builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a>28463     pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
28464         PipelineRasterizationConservativeStateCreateInfoEXTBuilder {
28465             inner: PipelineRasterizationConservativeStateCreateInfoEXT::default(),
28466             marker: ::std::marker::PhantomData,
28467         }
28468     }
28469 }
28470 #[repr(transparent)]
28471 pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
28472     inner: PipelineRasterizationConservativeStateCreateInfoEXT,
28473     marker: ::std::marker::PhantomData<&'a ()>,
28474 }
28475 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
28476     for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_>
28477 {
28478 }
28479 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
28480     for PipelineRasterizationConservativeStateCreateInfoEXT
28481 {
28482 }
28483 impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
28484     type Target = PipelineRasterizationConservativeStateCreateInfoEXT;
deref(&self) -> &Self::Target28485     fn deref(&self) -> &Self::Target {
28486         &self.inner
28487     }
28488 }
28489 impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28490     fn deref_mut(&mut self) -> &mut Self::Target {
28491         &mut self.inner
28492     }
28493 }
28494 impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
flags( mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT, ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a>28495     pub fn flags(
28496         mut self,
28497         flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
28498     ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
28499         self.inner.flags = flags;
28500         self
28501     }
conservative_rasterization_mode( mut self, conservative_rasterization_mode: ConservativeRasterizationModeEXT, ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a>28502     pub fn conservative_rasterization_mode(
28503         mut self,
28504         conservative_rasterization_mode: ConservativeRasterizationModeEXT,
28505     ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
28506         self.inner.conservative_rasterization_mode = conservative_rasterization_mode;
28507         self
28508     }
extra_primitive_overestimation_size( mut self, extra_primitive_overestimation_size: f32, ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a>28509     pub fn extra_primitive_overestimation_size(
28510         mut self,
28511         extra_primitive_overestimation_size: f32,
28512     ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
28513         self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size;
28514         self
28515     }
28516     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28517     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28518     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT28519     pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT {
28520         self.inner
28521     }
28522 }
28523 #[repr(C)]
28524 #[derive(Copy, Clone, Debug)]
28525 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>"]
28526 pub struct PhysicalDeviceDescriptorIndexingFeatures {
28527     pub s_type: StructureType,
28528     pub p_next: *mut c_void,
28529     pub shader_input_attachment_array_dynamic_indexing: Bool32,
28530     pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
28531     pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
28532     pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
28533     pub shader_sampled_image_array_non_uniform_indexing: Bool32,
28534     pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
28535     pub shader_storage_image_array_non_uniform_indexing: Bool32,
28536     pub shader_input_attachment_array_non_uniform_indexing: Bool32,
28537     pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
28538     pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
28539     pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
28540     pub descriptor_binding_sampled_image_update_after_bind: Bool32,
28541     pub descriptor_binding_storage_image_update_after_bind: Bool32,
28542     pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
28543     pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
28544     pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
28545     pub descriptor_binding_update_unused_while_pending: Bool32,
28546     pub descriptor_binding_partially_bound: Bool32,
28547     pub descriptor_binding_variable_descriptor_count: Bool32,
28548     pub runtime_descriptor_array: Bool32,
28549 }
28550 impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures {
default() -> PhysicalDeviceDescriptorIndexingFeatures28551     fn default() -> PhysicalDeviceDescriptorIndexingFeatures {
28552         PhysicalDeviceDescriptorIndexingFeatures {
28553             s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
28554             p_next: ::std::ptr::null_mut(),
28555             shader_input_attachment_array_dynamic_indexing: Bool32::default(),
28556             shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
28557             shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
28558             shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
28559             shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
28560             shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
28561             shader_storage_image_array_non_uniform_indexing: Bool32::default(),
28562             shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
28563             shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
28564             shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
28565             descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
28566             descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
28567             descriptor_binding_storage_image_update_after_bind: Bool32::default(),
28568             descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
28569             descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
28570             descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
28571             descriptor_binding_update_unused_while_pending: Bool32::default(),
28572             descriptor_binding_partially_bound: Bool32::default(),
28573             descriptor_binding_variable_descriptor_count: Bool32::default(),
28574             runtime_descriptor_array: Bool32::default(),
28575         }
28576     }
28577 }
28578 impl PhysicalDeviceDescriptorIndexingFeatures {
builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28579     pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28580         PhysicalDeviceDescriptorIndexingFeaturesBuilder {
28581             inner: PhysicalDeviceDescriptorIndexingFeatures::default(),
28582             marker: ::std::marker::PhantomData,
28583         }
28584     }
28585 }
28586 #[repr(transparent)]
28587 pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28588     inner: PhysicalDeviceDescriptorIndexingFeatures,
28589     marker: ::std::marker::PhantomData<&'a ()>,
28590 }
28591 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
28592 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {}
28593 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28594     type Target = PhysicalDeviceDescriptorIndexingFeatures;
deref(&self) -> &Self::Target28595     fn deref(&self) -> &Self::Target {
28596         &self.inner
28597     }
28598 }
28599 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28600     fn deref_mut(&mut self) -> &mut Self::Target {
28601         &mut self.inner
28602     }
28603 }
28604 impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
shader_input_attachment_array_dynamic_indexing( mut self, shader_input_attachment_array_dynamic_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28605     pub fn shader_input_attachment_array_dynamic_indexing(
28606         mut self,
28607         shader_input_attachment_array_dynamic_indexing: bool,
28608     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28609         self.inner.shader_input_attachment_array_dynamic_indexing =
28610             shader_input_attachment_array_dynamic_indexing.into();
28611         self
28612     }
shader_uniform_texel_buffer_array_dynamic_indexing( mut self, shader_uniform_texel_buffer_array_dynamic_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28613     pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
28614         mut self,
28615         shader_uniform_texel_buffer_array_dynamic_indexing: bool,
28616     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28617         self.inner
28618             .shader_uniform_texel_buffer_array_dynamic_indexing =
28619             shader_uniform_texel_buffer_array_dynamic_indexing.into();
28620         self
28621     }
shader_storage_texel_buffer_array_dynamic_indexing( mut self, shader_storage_texel_buffer_array_dynamic_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28622     pub fn shader_storage_texel_buffer_array_dynamic_indexing(
28623         mut self,
28624         shader_storage_texel_buffer_array_dynamic_indexing: bool,
28625     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28626         self.inner
28627             .shader_storage_texel_buffer_array_dynamic_indexing =
28628             shader_storage_texel_buffer_array_dynamic_indexing.into();
28629         self
28630     }
shader_uniform_buffer_array_non_uniform_indexing( mut self, shader_uniform_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28631     pub fn shader_uniform_buffer_array_non_uniform_indexing(
28632         mut self,
28633         shader_uniform_buffer_array_non_uniform_indexing: bool,
28634     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28635         self.inner.shader_uniform_buffer_array_non_uniform_indexing =
28636             shader_uniform_buffer_array_non_uniform_indexing.into();
28637         self
28638     }
shader_sampled_image_array_non_uniform_indexing( mut self, shader_sampled_image_array_non_uniform_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28639     pub fn shader_sampled_image_array_non_uniform_indexing(
28640         mut self,
28641         shader_sampled_image_array_non_uniform_indexing: bool,
28642     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28643         self.inner.shader_sampled_image_array_non_uniform_indexing =
28644             shader_sampled_image_array_non_uniform_indexing.into();
28645         self
28646     }
shader_storage_buffer_array_non_uniform_indexing( mut self, shader_storage_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28647     pub fn shader_storage_buffer_array_non_uniform_indexing(
28648         mut self,
28649         shader_storage_buffer_array_non_uniform_indexing: bool,
28650     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28651         self.inner.shader_storage_buffer_array_non_uniform_indexing =
28652             shader_storage_buffer_array_non_uniform_indexing.into();
28653         self
28654     }
shader_storage_image_array_non_uniform_indexing( mut self, shader_storage_image_array_non_uniform_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28655     pub fn shader_storage_image_array_non_uniform_indexing(
28656         mut self,
28657         shader_storage_image_array_non_uniform_indexing: bool,
28658     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28659         self.inner.shader_storage_image_array_non_uniform_indexing =
28660             shader_storage_image_array_non_uniform_indexing.into();
28661         self
28662     }
shader_input_attachment_array_non_uniform_indexing( mut self, shader_input_attachment_array_non_uniform_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28663     pub fn shader_input_attachment_array_non_uniform_indexing(
28664         mut self,
28665         shader_input_attachment_array_non_uniform_indexing: bool,
28666     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28667         self.inner
28668             .shader_input_attachment_array_non_uniform_indexing =
28669             shader_input_attachment_array_non_uniform_indexing.into();
28670         self
28671     }
shader_uniform_texel_buffer_array_non_uniform_indexing( mut self, shader_uniform_texel_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28672     pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
28673         mut self,
28674         shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
28675     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28676         self.inner
28677             .shader_uniform_texel_buffer_array_non_uniform_indexing =
28678             shader_uniform_texel_buffer_array_non_uniform_indexing.into();
28679         self
28680     }
shader_storage_texel_buffer_array_non_uniform_indexing( mut self, shader_storage_texel_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28681     pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
28682         mut self,
28683         shader_storage_texel_buffer_array_non_uniform_indexing: bool,
28684     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28685         self.inner
28686             .shader_storage_texel_buffer_array_non_uniform_indexing =
28687             shader_storage_texel_buffer_array_non_uniform_indexing.into();
28688         self
28689     }
descriptor_binding_uniform_buffer_update_after_bind( mut self, descriptor_binding_uniform_buffer_update_after_bind: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28690     pub fn descriptor_binding_uniform_buffer_update_after_bind(
28691         mut self,
28692         descriptor_binding_uniform_buffer_update_after_bind: bool,
28693     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28694         self.inner
28695             .descriptor_binding_uniform_buffer_update_after_bind =
28696             descriptor_binding_uniform_buffer_update_after_bind.into();
28697         self
28698     }
descriptor_binding_sampled_image_update_after_bind( mut self, descriptor_binding_sampled_image_update_after_bind: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28699     pub fn descriptor_binding_sampled_image_update_after_bind(
28700         mut self,
28701         descriptor_binding_sampled_image_update_after_bind: bool,
28702     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28703         self.inner
28704             .descriptor_binding_sampled_image_update_after_bind =
28705             descriptor_binding_sampled_image_update_after_bind.into();
28706         self
28707     }
descriptor_binding_storage_image_update_after_bind( mut self, descriptor_binding_storage_image_update_after_bind: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28708     pub fn descriptor_binding_storage_image_update_after_bind(
28709         mut self,
28710         descriptor_binding_storage_image_update_after_bind: bool,
28711     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28712         self.inner
28713             .descriptor_binding_storage_image_update_after_bind =
28714             descriptor_binding_storage_image_update_after_bind.into();
28715         self
28716     }
descriptor_binding_storage_buffer_update_after_bind( mut self, descriptor_binding_storage_buffer_update_after_bind: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28717     pub fn descriptor_binding_storage_buffer_update_after_bind(
28718         mut self,
28719         descriptor_binding_storage_buffer_update_after_bind: bool,
28720     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28721         self.inner
28722             .descriptor_binding_storage_buffer_update_after_bind =
28723             descriptor_binding_storage_buffer_update_after_bind.into();
28724         self
28725     }
descriptor_binding_uniform_texel_buffer_update_after_bind( mut self, descriptor_binding_uniform_texel_buffer_update_after_bind: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28726     pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
28727         mut self,
28728         descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
28729     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28730         self.inner
28731             .descriptor_binding_uniform_texel_buffer_update_after_bind =
28732             descriptor_binding_uniform_texel_buffer_update_after_bind.into();
28733         self
28734     }
descriptor_binding_storage_texel_buffer_update_after_bind( mut self, descriptor_binding_storage_texel_buffer_update_after_bind: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28735     pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
28736         mut self,
28737         descriptor_binding_storage_texel_buffer_update_after_bind: bool,
28738     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28739         self.inner
28740             .descriptor_binding_storage_texel_buffer_update_after_bind =
28741             descriptor_binding_storage_texel_buffer_update_after_bind.into();
28742         self
28743     }
descriptor_binding_update_unused_while_pending( mut self, descriptor_binding_update_unused_while_pending: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28744     pub fn descriptor_binding_update_unused_while_pending(
28745         mut self,
28746         descriptor_binding_update_unused_while_pending: bool,
28747     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28748         self.inner.descriptor_binding_update_unused_while_pending =
28749             descriptor_binding_update_unused_while_pending.into();
28750         self
28751     }
descriptor_binding_partially_bound( mut self, descriptor_binding_partially_bound: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28752     pub fn descriptor_binding_partially_bound(
28753         mut self,
28754         descriptor_binding_partially_bound: bool,
28755     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28756         self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
28757         self
28758     }
descriptor_binding_variable_descriptor_count( mut self, descriptor_binding_variable_descriptor_count: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28759     pub fn descriptor_binding_variable_descriptor_count(
28760         mut self,
28761         descriptor_binding_variable_descriptor_count: bool,
28762     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28763         self.inner.descriptor_binding_variable_descriptor_count =
28764             descriptor_binding_variable_descriptor_count.into();
28765         self
28766     }
runtime_descriptor_array( mut self, runtime_descriptor_array: bool, ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>28767     pub fn runtime_descriptor_array(
28768         mut self,
28769         runtime_descriptor_array: bool,
28770     ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
28771         self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
28772         self
28773     }
28774     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
28775     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
28776     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorIndexingFeatures28777     pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures {
28778         self.inner
28779     }
28780 }
28781 #[repr(C)]
28782 #[derive(Copy, Clone, Debug)]
28783 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>"]
28784 pub struct PhysicalDeviceDescriptorIndexingProperties {
28785     pub s_type: StructureType,
28786     pub p_next: *mut c_void,
28787     pub max_update_after_bind_descriptors_in_all_pools: u32,
28788     pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
28789     pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
28790     pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
28791     pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
28792     pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
28793     pub robust_buffer_access_update_after_bind: Bool32,
28794     pub quad_divergent_implicit_lod: Bool32,
28795     pub max_per_stage_descriptor_update_after_bind_samplers: u32,
28796     pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
28797     pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
28798     pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
28799     pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
28800     pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
28801     pub max_per_stage_update_after_bind_resources: u32,
28802     pub max_descriptor_set_update_after_bind_samplers: u32,
28803     pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
28804     pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
28805     pub max_descriptor_set_update_after_bind_storage_buffers: u32,
28806     pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
28807     pub max_descriptor_set_update_after_bind_sampled_images: u32,
28808     pub max_descriptor_set_update_after_bind_storage_images: u32,
28809     pub max_descriptor_set_update_after_bind_input_attachments: u32,
28810 }
28811 impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties {
default() -> PhysicalDeviceDescriptorIndexingProperties28812     fn default() -> PhysicalDeviceDescriptorIndexingProperties {
28813         PhysicalDeviceDescriptorIndexingProperties {
28814             s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
28815             p_next: ::std::ptr::null_mut(),
28816             max_update_after_bind_descriptors_in_all_pools: u32::default(),
28817             shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
28818             shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
28819             shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
28820             shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
28821             shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
28822             robust_buffer_access_update_after_bind: Bool32::default(),
28823             quad_divergent_implicit_lod: Bool32::default(),
28824             max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
28825             max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
28826             max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
28827             max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
28828             max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
28829             max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
28830             max_per_stage_update_after_bind_resources: u32::default(),
28831             max_descriptor_set_update_after_bind_samplers: u32::default(),
28832             max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
28833             max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
28834             max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
28835             max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
28836             max_descriptor_set_update_after_bind_sampled_images: u32::default(),
28837             max_descriptor_set_update_after_bind_storage_images: u32::default(),
28838             max_descriptor_set_update_after_bind_input_attachments: u32::default(),
28839         }
28840     }
28841 }
28842 impl PhysicalDeviceDescriptorIndexingProperties {
builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28843     pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28844         PhysicalDeviceDescriptorIndexingPropertiesBuilder {
28845             inner: PhysicalDeviceDescriptorIndexingProperties::default(),
28846             marker: ::std::marker::PhantomData,
28847         }
28848     }
28849 }
28850 #[repr(transparent)]
28851 pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28852     inner: PhysicalDeviceDescriptorIndexingProperties,
28853     marker: ::std::marker::PhantomData<&'a ()>,
28854 }
28855 unsafe impl ExtendsPhysicalDeviceProperties2
28856     for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_>
28857 {
28858 }
28859 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {}
28860 impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28861     type Target = PhysicalDeviceDescriptorIndexingProperties;
deref(&self) -> &Self::Target28862     fn deref(&self) -> &Self::Target {
28863         &self.inner
28864     }
28865 }
28866 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target28867     fn deref_mut(&mut self) -> &mut Self::Target {
28868         &mut self.inner
28869     }
28870 }
28871 impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
max_update_after_bind_descriptors_in_all_pools( mut self, max_update_after_bind_descriptors_in_all_pools: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28872     pub fn max_update_after_bind_descriptors_in_all_pools(
28873         mut self,
28874         max_update_after_bind_descriptors_in_all_pools: u32,
28875     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28876         self.inner.max_update_after_bind_descriptors_in_all_pools =
28877             max_update_after_bind_descriptors_in_all_pools;
28878         self
28879     }
shader_uniform_buffer_array_non_uniform_indexing_native( mut self, shader_uniform_buffer_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28880     pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
28881         mut self,
28882         shader_uniform_buffer_array_non_uniform_indexing_native: bool,
28883     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28884         self.inner
28885             .shader_uniform_buffer_array_non_uniform_indexing_native =
28886             shader_uniform_buffer_array_non_uniform_indexing_native.into();
28887         self
28888     }
shader_sampled_image_array_non_uniform_indexing_native( mut self, shader_sampled_image_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28889     pub fn shader_sampled_image_array_non_uniform_indexing_native(
28890         mut self,
28891         shader_sampled_image_array_non_uniform_indexing_native: bool,
28892     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28893         self.inner
28894             .shader_sampled_image_array_non_uniform_indexing_native =
28895             shader_sampled_image_array_non_uniform_indexing_native.into();
28896         self
28897     }
shader_storage_buffer_array_non_uniform_indexing_native( mut self, shader_storage_buffer_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28898     pub fn shader_storage_buffer_array_non_uniform_indexing_native(
28899         mut self,
28900         shader_storage_buffer_array_non_uniform_indexing_native: bool,
28901     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28902         self.inner
28903             .shader_storage_buffer_array_non_uniform_indexing_native =
28904             shader_storage_buffer_array_non_uniform_indexing_native.into();
28905         self
28906     }
shader_storage_image_array_non_uniform_indexing_native( mut self, shader_storage_image_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28907     pub fn shader_storage_image_array_non_uniform_indexing_native(
28908         mut self,
28909         shader_storage_image_array_non_uniform_indexing_native: bool,
28910     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28911         self.inner
28912             .shader_storage_image_array_non_uniform_indexing_native =
28913             shader_storage_image_array_non_uniform_indexing_native.into();
28914         self
28915     }
shader_input_attachment_array_non_uniform_indexing_native( mut self, shader_input_attachment_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28916     pub fn shader_input_attachment_array_non_uniform_indexing_native(
28917         mut self,
28918         shader_input_attachment_array_non_uniform_indexing_native: bool,
28919     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28920         self.inner
28921             .shader_input_attachment_array_non_uniform_indexing_native =
28922             shader_input_attachment_array_non_uniform_indexing_native.into();
28923         self
28924     }
robust_buffer_access_update_after_bind( mut self, robust_buffer_access_update_after_bind: bool, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28925     pub fn robust_buffer_access_update_after_bind(
28926         mut self,
28927         robust_buffer_access_update_after_bind: bool,
28928     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28929         self.inner.robust_buffer_access_update_after_bind =
28930             robust_buffer_access_update_after_bind.into();
28931         self
28932     }
quad_divergent_implicit_lod( mut self, quad_divergent_implicit_lod: bool, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28933     pub fn quad_divergent_implicit_lod(
28934         mut self,
28935         quad_divergent_implicit_lod: bool,
28936     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28937         self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
28938         self
28939     }
max_per_stage_descriptor_update_after_bind_samplers( mut self, max_per_stage_descriptor_update_after_bind_samplers: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28940     pub fn max_per_stage_descriptor_update_after_bind_samplers(
28941         mut self,
28942         max_per_stage_descriptor_update_after_bind_samplers: u32,
28943     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28944         self.inner
28945             .max_per_stage_descriptor_update_after_bind_samplers =
28946             max_per_stage_descriptor_update_after_bind_samplers;
28947         self
28948     }
max_per_stage_descriptor_update_after_bind_uniform_buffers( mut self, max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28949     pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
28950         mut self,
28951         max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
28952     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28953         self.inner
28954             .max_per_stage_descriptor_update_after_bind_uniform_buffers =
28955             max_per_stage_descriptor_update_after_bind_uniform_buffers;
28956         self
28957     }
max_per_stage_descriptor_update_after_bind_storage_buffers( mut self, max_per_stage_descriptor_update_after_bind_storage_buffers: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28958     pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
28959         mut self,
28960         max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
28961     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28962         self.inner
28963             .max_per_stage_descriptor_update_after_bind_storage_buffers =
28964             max_per_stage_descriptor_update_after_bind_storage_buffers;
28965         self
28966     }
max_per_stage_descriptor_update_after_bind_sampled_images( mut self, max_per_stage_descriptor_update_after_bind_sampled_images: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28967     pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
28968         mut self,
28969         max_per_stage_descriptor_update_after_bind_sampled_images: u32,
28970     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28971         self.inner
28972             .max_per_stage_descriptor_update_after_bind_sampled_images =
28973             max_per_stage_descriptor_update_after_bind_sampled_images;
28974         self
28975     }
max_per_stage_descriptor_update_after_bind_storage_images( mut self, max_per_stage_descriptor_update_after_bind_storage_images: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28976     pub fn max_per_stage_descriptor_update_after_bind_storage_images(
28977         mut self,
28978         max_per_stage_descriptor_update_after_bind_storage_images: u32,
28979     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28980         self.inner
28981             .max_per_stage_descriptor_update_after_bind_storage_images =
28982             max_per_stage_descriptor_update_after_bind_storage_images;
28983         self
28984     }
max_per_stage_descriptor_update_after_bind_input_attachments( mut self, max_per_stage_descriptor_update_after_bind_input_attachments: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28985     pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
28986         mut self,
28987         max_per_stage_descriptor_update_after_bind_input_attachments: u32,
28988     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28989         self.inner
28990             .max_per_stage_descriptor_update_after_bind_input_attachments =
28991             max_per_stage_descriptor_update_after_bind_input_attachments;
28992         self
28993     }
max_per_stage_update_after_bind_resources( mut self, max_per_stage_update_after_bind_resources: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>28994     pub fn max_per_stage_update_after_bind_resources(
28995         mut self,
28996         max_per_stage_update_after_bind_resources: u32,
28997     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
28998         self.inner.max_per_stage_update_after_bind_resources =
28999             max_per_stage_update_after_bind_resources;
29000         self
29001     }
max_descriptor_set_update_after_bind_samplers( mut self, max_descriptor_set_update_after_bind_samplers: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29002     pub fn max_descriptor_set_update_after_bind_samplers(
29003         mut self,
29004         max_descriptor_set_update_after_bind_samplers: u32,
29005     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29006         self.inner.max_descriptor_set_update_after_bind_samplers =
29007             max_descriptor_set_update_after_bind_samplers;
29008         self
29009     }
max_descriptor_set_update_after_bind_uniform_buffers( mut self, max_descriptor_set_update_after_bind_uniform_buffers: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29010     pub fn max_descriptor_set_update_after_bind_uniform_buffers(
29011         mut self,
29012         max_descriptor_set_update_after_bind_uniform_buffers: u32,
29013     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29014         self.inner
29015             .max_descriptor_set_update_after_bind_uniform_buffers =
29016             max_descriptor_set_update_after_bind_uniform_buffers;
29017         self
29018     }
max_descriptor_set_update_after_bind_uniform_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29019     pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
29020         mut self,
29021         max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
29022     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29023         self.inner
29024             .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
29025             max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
29026         self
29027     }
max_descriptor_set_update_after_bind_storage_buffers( mut self, max_descriptor_set_update_after_bind_storage_buffers: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29028     pub fn max_descriptor_set_update_after_bind_storage_buffers(
29029         mut self,
29030         max_descriptor_set_update_after_bind_storage_buffers: u32,
29031     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29032         self.inner
29033             .max_descriptor_set_update_after_bind_storage_buffers =
29034             max_descriptor_set_update_after_bind_storage_buffers;
29035         self
29036     }
max_descriptor_set_update_after_bind_storage_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29037     pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
29038         mut self,
29039         max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
29040     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29041         self.inner
29042             .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
29043             max_descriptor_set_update_after_bind_storage_buffers_dynamic;
29044         self
29045     }
max_descriptor_set_update_after_bind_sampled_images( mut self, max_descriptor_set_update_after_bind_sampled_images: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29046     pub fn max_descriptor_set_update_after_bind_sampled_images(
29047         mut self,
29048         max_descriptor_set_update_after_bind_sampled_images: u32,
29049     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29050         self.inner
29051             .max_descriptor_set_update_after_bind_sampled_images =
29052             max_descriptor_set_update_after_bind_sampled_images;
29053         self
29054     }
max_descriptor_set_update_after_bind_storage_images( mut self, max_descriptor_set_update_after_bind_storage_images: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29055     pub fn max_descriptor_set_update_after_bind_storage_images(
29056         mut self,
29057         max_descriptor_set_update_after_bind_storage_images: u32,
29058     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29059         self.inner
29060             .max_descriptor_set_update_after_bind_storage_images =
29061             max_descriptor_set_update_after_bind_storage_images;
29062         self
29063     }
max_descriptor_set_update_after_bind_input_attachments( mut self, max_descriptor_set_update_after_bind_input_attachments: u32, ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a>29064     pub fn max_descriptor_set_update_after_bind_input_attachments(
29065         mut self,
29066         max_descriptor_set_update_after_bind_input_attachments: u32,
29067     ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
29068         self.inner
29069             .max_descriptor_set_update_after_bind_input_attachments =
29070             max_descriptor_set_update_after_bind_input_attachments;
29071         self
29072     }
29073     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29074     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29075     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDescriptorIndexingProperties29076     pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties {
29077         self.inner
29078     }
29079 }
29080 #[repr(C)]
29081 #[derive(Copy, Clone, Debug)]
29082 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>"]
29083 pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
29084     pub s_type: StructureType,
29085     pub p_next: *const c_void,
29086     pub binding_count: u32,
29087     pub p_binding_flags: *const DescriptorBindingFlags,
29088 }
29089 impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo {
default() -> DescriptorSetLayoutBindingFlagsCreateInfo29090     fn default() -> DescriptorSetLayoutBindingFlagsCreateInfo {
29091         DescriptorSetLayoutBindingFlagsCreateInfo {
29092             s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
29093             p_next: ::std::ptr::null(),
29094             binding_count: u32::default(),
29095             p_binding_flags: ::std::ptr::null(),
29096         }
29097     }
29098 }
29099 impl DescriptorSetLayoutBindingFlagsCreateInfo {
builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a>29100     pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
29101         DescriptorSetLayoutBindingFlagsCreateInfoBuilder {
29102             inner: DescriptorSetLayoutBindingFlagsCreateInfo::default(),
29103             marker: ::std::marker::PhantomData,
29104         }
29105     }
29106 }
29107 #[repr(transparent)]
29108 pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
29109     inner: DescriptorSetLayoutBindingFlagsCreateInfo,
29110     marker: ::std::marker::PhantomData<&'a ()>,
29111 }
29112 unsafe impl ExtendsDescriptorSetLayoutCreateInfo
29113     for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_>
29114 {
29115 }
29116 unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {}
29117 impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
29118     type Target = DescriptorSetLayoutBindingFlagsCreateInfo;
deref(&self) -> &Self::Target29119     fn deref(&self) -> &Self::Target {
29120         &self.inner
29121     }
29122 }
29123 impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29124     fn deref_mut(&mut self) -> &mut Self::Target {
29125         &mut self.inner
29126     }
29127 }
29128 impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
binding_flags( mut self, binding_flags: &'a [DescriptorBindingFlags], ) -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a>29129     pub fn binding_flags(
29130         mut self,
29131         binding_flags: &'a [DescriptorBindingFlags],
29132     ) -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
29133         self.inner.binding_count = binding_flags.len() as _;
29134         self.inner.p_binding_flags = binding_flags.as_ptr();
29135         self
29136     }
29137     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29138     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29139     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo29140     pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo {
29141         self.inner
29142     }
29143 }
29144 #[repr(C)]
29145 #[derive(Copy, Clone, Debug)]
29146 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>"]
29147 pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
29148     pub s_type: StructureType,
29149     pub p_next: *const c_void,
29150     pub descriptor_set_count: u32,
29151     pub p_descriptor_counts: *const u32,
29152 }
29153 impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo {
default() -> DescriptorSetVariableDescriptorCountAllocateInfo29154     fn default() -> DescriptorSetVariableDescriptorCountAllocateInfo {
29155         DescriptorSetVariableDescriptorCountAllocateInfo {
29156             s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
29157             p_next: ::std::ptr::null(),
29158             descriptor_set_count: u32::default(),
29159             p_descriptor_counts: ::std::ptr::null(),
29160         }
29161     }
29162 }
29163 impl DescriptorSetVariableDescriptorCountAllocateInfo {
builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a>29164     pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
29165         DescriptorSetVariableDescriptorCountAllocateInfoBuilder {
29166             inner: DescriptorSetVariableDescriptorCountAllocateInfo::default(),
29167             marker: ::std::marker::PhantomData,
29168         }
29169     }
29170 }
29171 #[repr(transparent)]
29172 pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
29173     inner: DescriptorSetVariableDescriptorCountAllocateInfo,
29174     marker: ::std::marker::PhantomData<&'a ()>,
29175 }
29176 unsafe impl ExtendsDescriptorSetAllocateInfo
29177     for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_>
29178 {
29179 }
29180 unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {}
29181 impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
29182     type Target = DescriptorSetVariableDescriptorCountAllocateInfo;
deref(&self) -> &Self::Target29183     fn deref(&self) -> &Self::Target {
29184         &self.inner
29185     }
29186 }
29187 impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29188     fn deref_mut(&mut self) -> &mut Self::Target {
29189         &mut self.inner
29190     }
29191 }
29192 impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
descriptor_counts( mut self, descriptor_counts: &'a [u32], ) -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a>29193     pub fn descriptor_counts(
29194         mut self,
29195         descriptor_counts: &'a [u32],
29196     ) -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
29197         self.inner.descriptor_set_count = descriptor_counts.len() as _;
29198         self.inner.p_descriptor_counts = descriptor_counts.as_ptr();
29199         self
29200     }
29201     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29202     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29203     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo29204     pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo {
29205         self.inner
29206     }
29207 }
29208 #[repr(C)]
29209 #[derive(Copy, Clone, Debug)]
29210 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>"]
29211 pub struct DescriptorSetVariableDescriptorCountLayoutSupport {
29212     pub s_type: StructureType,
29213     pub p_next: *mut c_void,
29214     pub max_variable_descriptor_count: u32,
29215 }
29216 impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport {
default() -> DescriptorSetVariableDescriptorCountLayoutSupport29217     fn default() -> DescriptorSetVariableDescriptorCountLayoutSupport {
29218         DescriptorSetVariableDescriptorCountLayoutSupport {
29219             s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
29220             p_next: ::std::ptr::null_mut(),
29221             max_variable_descriptor_count: u32::default(),
29222         }
29223     }
29224 }
29225 impl DescriptorSetVariableDescriptorCountLayoutSupport {
builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a>29226     pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
29227         DescriptorSetVariableDescriptorCountLayoutSupportBuilder {
29228             inner: DescriptorSetVariableDescriptorCountLayoutSupport::default(),
29229             marker: ::std::marker::PhantomData,
29230         }
29231     }
29232 }
29233 #[repr(transparent)]
29234 pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
29235     inner: DescriptorSetVariableDescriptorCountLayoutSupport,
29236     marker: ::std::marker::PhantomData<&'a ()>,
29237 }
29238 unsafe impl ExtendsDescriptorSetLayoutSupport
29239     for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_>
29240 {
29241 }
29242 unsafe impl ExtendsDescriptorSetLayoutSupport
29243     for DescriptorSetVariableDescriptorCountLayoutSupport
29244 {
29245 }
29246 impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
29247     type Target = DescriptorSetVariableDescriptorCountLayoutSupport;
deref(&self) -> &Self::Target29248     fn deref(&self) -> &Self::Target {
29249         &self.inner
29250     }
29251 }
29252 impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29253     fn deref_mut(&mut self) -> &mut Self::Target {
29254         &mut self.inner
29255     }
29256 }
29257 impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
max_variable_descriptor_count( mut self, max_variable_descriptor_count: u32, ) -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a>29258     pub fn max_variable_descriptor_count(
29259         mut self,
29260         max_variable_descriptor_count: u32,
29261     ) -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
29262         self.inner.max_variable_descriptor_count = max_variable_descriptor_count;
29263         self
29264     }
29265     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29266     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29267     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport29268     pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport {
29269         self.inner
29270     }
29271 }
29272 #[repr(C)]
29273 #[derive(Copy, Clone, Debug)]
29274 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescription2.html>"]
29275 pub struct AttachmentDescription2 {
29276     pub s_type: StructureType,
29277     pub p_next: *const c_void,
29278     pub flags: AttachmentDescriptionFlags,
29279     pub format: Format,
29280     pub samples: SampleCountFlags,
29281     pub load_op: AttachmentLoadOp,
29282     pub store_op: AttachmentStoreOp,
29283     pub stencil_load_op: AttachmentLoadOp,
29284     pub stencil_store_op: AttachmentStoreOp,
29285     pub initial_layout: ImageLayout,
29286     pub final_layout: ImageLayout,
29287 }
29288 impl ::std::default::Default for AttachmentDescription2 {
default() -> AttachmentDescription229289     fn default() -> AttachmentDescription2 {
29290         AttachmentDescription2 {
29291             s_type: StructureType::ATTACHMENT_DESCRIPTION_2,
29292             p_next: ::std::ptr::null(),
29293             flags: AttachmentDescriptionFlags::default(),
29294             format: Format::default(),
29295             samples: SampleCountFlags::default(),
29296             load_op: AttachmentLoadOp::default(),
29297             store_op: AttachmentStoreOp::default(),
29298             stencil_load_op: AttachmentLoadOp::default(),
29299             stencil_store_op: AttachmentStoreOp::default(),
29300             initial_layout: ImageLayout::default(),
29301             final_layout: ImageLayout::default(),
29302         }
29303     }
29304 }
29305 impl AttachmentDescription2 {
builder<'a>() -> AttachmentDescription2Builder<'a>29306     pub fn builder<'a>() -> AttachmentDescription2Builder<'a> {
29307         AttachmentDescription2Builder {
29308             inner: AttachmentDescription2::default(),
29309             marker: ::std::marker::PhantomData,
29310         }
29311     }
29312 }
29313 #[repr(transparent)]
29314 pub struct AttachmentDescription2Builder<'a> {
29315     inner: AttachmentDescription2,
29316     marker: ::std::marker::PhantomData<&'a ()>,
29317 }
29318 pub unsafe trait ExtendsAttachmentDescription2 {}
29319 impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> {
29320     type Target = AttachmentDescription2;
deref(&self) -> &Self::Target29321     fn deref(&self) -> &Self::Target {
29322         &self.inner
29323     }
29324 }
29325 impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target29326     fn deref_mut(&mut self) -> &mut Self::Target {
29327         &mut self.inner
29328     }
29329 }
29330 impl<'a> AttachmentDescription2Builder<'a> {
flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescription2Builder<'a>29331     pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescription2Builder<'a> {
29332         self.inner.flags = flags;
29333         self
29334     }
format(mut self, format: Format) -> AttachmentDescription2Builder<'a>29335     pub fn format(mut self, format: Format) -> AttachmentDescription2Builder<'a> {
29336         self.inner.format = format;
29337         self
29338     }
samples(mut self, samples: SampleCountFlags) -> AttachmentDescription2Builder<'a>29339     pub fn samples(mut self, samples: SampleCountFlags) -> AttachmentDescription2Builder<'a> {
29340         self.inner.samples = samples;
29341         self
29342     }
load_op(mut self, load_op: AttachmentLoadOp) -> AttachmentDescription2Builder<'a>29343     pub fn load_op(mut self, load_op: AttachmentLoadOp) -> AttachmentDescription2Builder<'a> {
29344         self.inner.load_op = load_op;
29345         self
29346     }
store_op(mut self, store_op: AttachmentStoreOp) -> AttachmentDescription2Builder<'a>29347     pub fn store_op(mut self, store_op: AttachmentStoreOp) -> AttachmentDescription2Builder<'a> {
29348         self.inner.store_op = store_op;
29349         self
29350     }
stencil_load_op( mut self, stencil_load_op: AttachmentLoadOp, ) -> AttachmentDescription2Builder<'a>29351     pub fn stencil_load_op(
29352         mut self,
29353         stencil_load_op: AttachmentLoadOp,
29354     ) -> AttachmentDescription2Builder<'a> {
29355         self.inner.stencil_load_op = stencil_load_op;
29356         self
29357     }
stencil_store_op( mut self, stencil_store_op: AttachmentStoreOp, ) -> AttachmentDescription2Builder<'a>29358     pub fn stencil_store_op(
29359         mut self,
29360         stencil_store_op: AttachmentStoreOp,
29361     ) -> AttachmentDescription2Builder<'a> {
29362         self.inner.stencil_store_op = stencil_store_op;
29363         self
29364     }
initial_layout( mut self, initial_layout: ImageLayout, ) -> AttachmentDescription2Builder<'a>29365     pub fn initial_layout(
29366         mut self,
29367         initial_layout: ImageLayout,
29368     ) -> AttachmentDescription2Builder<'a> {
29369         self.inner.initial_layout = initial_layout;
29370         self
29371     }
final_layout(mut self, final_layout: ImageLayout) -> AttachmentDescription2Builder<'a>29372     pub fn final_layout(mut self, final_layout: ImageLayout) -> AttachmentDescription2Builder<'a> {
29373         self.inner.final_layout = final_layout;
29374         self
29375     }
29376     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
29377     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
29378     #[doc = r" valid extension structs can be pushed into the chain."]
29379     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
29380     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAttachmentDescription2>( mut self, next: &'a mut T, ) -> AttachmentDescription2Builder<'a>29381     pub fn push_next<T: ExtendsAttachmentDescription2>(
29382         mut self,
29383         next: &'a mut T,
29384     ) -> AttachmentDescription2Builder<'a> {
29385         unsafe {
29386             let next_ptr = next as *mut T as *mut BaseOutStructure;
29387             let last_next = ptr_chain_iter(next).last().unwrap();
29388             (*last_next).p_next = self.inner.p_next as _;
29389             self.inner.p_next = next_ptr as _;
29390         }
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."]
build(self) -> AttachmentDescription229396     pub fn build(self) -> AttachmentDescription2 {
29397         self.inner
29398     }
29399 }
29400 #[repr(C)]
29401 #[derive(Copy, Clone, Debug)]
29402 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReference2.html>"]
29403 pub struct AttachmentReference2 {
29404     pub s_type: StructureType,
29405     pub p_next: *const c_void,
29406     pub attachment: u32,
29407     pub layout: ImageLayout,
29408     pub aspect_mask: ImageAspectFlags,
29409 }
29410 impl ::std::default::Default for AttachmentReference2 {
default() -> AttachmentReference229411     fn default() -> AttachmentReference2 {
29412         AttachmentReference2 {
29413             s_type: StructureType::ATTACHMENT_REFERENCE_2,
29414             p_next: ::std::ptr::null(),
29415             attachment: u32::default(),
29416             layout: ImageLayout::default(),
29417             aspect_mask: ImageAspectFlags::default(),
29418         }
29419     }
29420 }
29421 impl AttachmentReference2 {
builder<'a>() -> AttachmentReference2Builder<'a>29422     pub fn builder<'a>() -> AttachmentReference2Builder<'a> {
29423         AttachmentReference2Builder {
29424             inner: AttachmentReference2::default(),
29425             marker: ::std::marker::PhantomData,
29426         }
29427     }
29428 }
29429 #[repr(transparent)]
29430 pub struct AttachmentReference2Builder<'a> {
29431     inner: AttachmentReference2,
29432     marker: ::std::marker::PhantomData<&'a ()>,
29433 }
29434 pub unsafe trait ExtendsAttachmentReference2 {}
29435 impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> {
29436     type Target = AttachmentReference2;
deref(&self) -> &Self::Target29437     fn deref(&self) -> &Self::Target {
29438         &self.inner
29439     }
29440 }
29441 impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target29442     fn deref_mut(&mut self) -> &mut Self::Target {
29443         &mut self.inner
29444     }
29445 }
29446 impl<'a> AttachmentReference2Builder<'a> {
attachment(mut self, attachment: u32) -> AttachmentReference2Builder<'a>29447     pub fn attachment(mut self, attachment: u32) -> AttachmentReference2Builder<'a> {
29448         self.inner.attachment = attachment;
29449         self
29450     }
layout(mut self, layout: ImageLayout) -> AttachmentReference2Builder<'a>29451     pub fn layout(mut self, layout: ImageLayout) -> AttachmentReference2Builder<'a> {
29452         self.inner.layout = layout;
29453         self
29454     }
aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> AttachmentReference2Builder<'a>29455     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> AttachmentReference2Builder<'a> {
29456         self.inner.aspect_mask = aspect_mask;
29457         self
29458     }
29459     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
29460     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
29461     #[doc = r" valid extension structs can be pushed into the chain."]
29462     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
29463     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAttachmentReference2>( mut self, next: &'a mut T, ) -> AttachmentReference2Builder<'a>29464     pub fn push_next<T: ExtendsAttachmentReference2>(
29465         mut self,
29466         next: &'a mut T,
29467     ) -> AttachmentReference2Builder<'a> {
29468         unsafe {
29469             let next_ptr = next as *mut T as *mut BaseOutStructure;
29470             let last_next = ptr_chain_iter(next).last().unwrap();
29471             (*last_next).p_next = self.inner.p_next as _;
29472             self.inner.p_next = next_ptr as _;
29473         }
29474         self
29475     }
29476     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29477     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29478     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentReference229479     pub fn build(self) -> AttachmentReference2 {
29480         self.inner
29481     }
29482 }
29483 #[repr(C)]
29484 #[derive(Copy, Clone, Debug)]
29485 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescription2.html>"]
29486 pub struct SubpassDescription2 {
29487     pub s_type: StructureType,
29488     pub p_next: *const c_void,
29489     pub flags: SubpassDescriptionFlags,
29490     pub pipeline_bind_point: PipelineBindPoint,
29491     pub view_mask: u32,
29492     pub input_attachment_count: u32,
29493     pub p_input_attachments: *const AttachmentReference2,
29494     pub color_attachment_count: u32,
29495     pub p_color_attachments: *const AttachmentReference2,
29496     pub p_resolve_attachments: *const AttachmentReference2,
29497     pub p_depth_stencil_attachment: *const AttachmentReference2,
29498     pub preserve_attachment_count: u32,
29499     pub p_preserve_attachments: *const u32,
29500 }
29501 impl ::std::default::Default for SubpassDescription2 {
default() -> SubpassDescription229502     fn default() -> SubpassDescription2 {
29503         SubpassDescription2 {
29504             s_type: StructureType::SUBPASS_DESCRIPTION_2,
29505             p_next: ::std::ptr::null(),
29506             flags: SubpassDescriptionFlags::default(),
29507             pipeline_bind_point: PipelineBindPoint::default(),
29508             view_mask: u32::default(),
29509             input_attachment_count: u32::default(),
29510             p_input_attachments: ::std::ptr::null(),
29511             color_attachment_count: u32::default(),
29512             p_color_attachments: ::std::ptr::null(),
29513             p_resolve_attachments: ::std::ptr::null(),
29514             p_depth_stencil_attachment: ::std::ptr::null(),
29515             preserve_attachment_count: u32::default(),
29516             p_preserve_attachments: ::std::ptr::null(),
29517         }
29518     }
29519 }
29520 impl SubpassDescription2 {
builder<'a>() -> SubpassDescription2Builder<'a>29521     pub fn builder<'a>() -> SubpassDescription2Builder<'a> {
29522         SubpassDescription2Builder {
29523             inner: SubpassDescription2::default(),
29524             marker: ::std::marker::PhantomData,
29525         }
29526     }
29527 }
29528 #[repr(transparent)]
29529 pub struct SubpassDescription2Builder<'a> {
29530     inner: SubpassDescription2,
29531     marker: ::std::marker::PhantomData<&'a ()>,
29532 }
29533 pub unsafe trait ExtendsSubpassDescription2 {}
29534 impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> {
29535     type Target = SubpassDescription2;
deref(&self) -> &Self::Target29536     fn deref(&self) -> &Self::Target {
29537         &self.inner
29538     }
29539 }
29540 impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target29541     fn deref_mut(&mut self) -> &mut Self::Target {
29542         &mut self.inner
29543     }
29544 }
29545 impl<'a> SubpassDescription2Builder<'a> {
flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescription2Builder<'a>29546     pub fn flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescription2Builder<'a> {
29547         self.inner.flags = flags;
29548         self
29549     }
pipeline_bind_point( mut self, pipeline_bind_point: PipelineBindPoint, ) -> SubpassDescription2Builder<'a>29550     pub fn pipeline_bind_point(
29551         mut self,
29552         pipeline_bind_point: PipelineBindPoint,
29553     ) -> SubpassDescription2Builder<'a> {
29554         self.inner.pipeline_bind_point = pipeline_bind_point;
29555         self
29556     }
view_mask(mut self, view_mask: u32) -> SubpassDescription2Builder<'a>29557     pub fn view_mask(mut self, view_mask: u32) -> SubpassDescription2Builder<'a> {
29558         self.inner.view_mask = view_mask;
29559         self
29560     }
input_attachments( mut self, input_attachments: &'a [AttachmentReference2], ) -> SubpassDescription2Builder<'a>29561     pub fn input_attachments(
29562         mut self,
29563         input_attachments: &'a [AttachmentReference2],
29564     ) -> SubpassDescription2Builder<'a> {
29565         self.inner.input_attachment_count = input_attachments.len() as _;
29566         self.inner.p_input_attachments = input_attachments.as_ptr();
29567         self
29568     }
color_attachments( mut self, color_attachments: &'a [AttachmentReference2], ) -> SubpassDescription2Builder<'a>29569     pub fn color_attachments(
29570         mut self,
29571         color_attachments: &'a [AttachmentReference2],
29572     ) -> SubpassDescription2Builder<'a> {
29573         self.inner.color_attachment_count = color_attachments.len() as _;
29574         self.inner.p_color_attachments = color_attachments.as_ptr();
29575         self
29576     }
resolve_attachments( mut self, resolve_attachments: &'a [AttachmentReference2], ) -> SubpassDescription2Builder<'a>29577     pub fn resolve_attachments(
29578         mut self,
29579         resolve_attachments: &'a [AttachmentReference2],
29580     ) -> SubpassDescription2Builder<'a> {
29581         self.inner.color_attachment_count = resolve_attachments.len() as _;
29582         self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
29583         self
29584     }
depth_stencil_attachment( mut self, depth_stencil_attachment: &'a AttachmentReference2, ) -> SubpassDescription2Builder<'a>29585     pub fn depth_stencil_attachment(
29586         mut self,
29587         depth_stencil_attachment: &'a AttachmentReference2,
29588     ) -> SubpassDescription2Builder<'a> {
29589         self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
29590         self
29591     }
preserve_attachments( mut self, preserve_attachments: &'a [u32], ) -> SubpassDescription2Builder<'a>29592     pub fn preserve_attachments(
29593         mut self,
29594         preserve_attachments: &'a [u32],
29595     ) -> SubpassDescription2Builder<'a> {
29596         self.inner.preserve_attachment_count = preserve_attachments.len() as _;
29597         self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
29598         self
29599     }
29600     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
29601     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
29602     #[doc = r" valid extension structs can be pushed into the chain."]
29603     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
29604     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubpassDescription2>( mut self, next: &'a mut T, ) -> SubpassDescription2Builder<'a>29605     pub fn push_next<T: ExtendsSubpassDescription2>(
29606         mut self,
29607         next: &'a mut T,
29608     ) -> SubpassDescription2Builder<'a> {
29609         unsafe {
29610             let next_ptr = next as *mut T as *mut BaseOutStructure;
29611             let last_next = ptr_chain_iter(next).last().unwrap();
29612             (*last_next).p_next = self.inner.p_next as _;
29613             self.inner.p_next = next_ptr as _;
29614         }
29615         self
29616     }
29617     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29618     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29619     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDescription229620     pub fn build(self) -> SubpassDescription2 {
29621         self.inner
29622     }
29623 }
29624 #[repr(C)]
29625 #[derive(Copy, Clone, Debug)]
29626 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDependency2.html>"]
29627 pub struct SubpassDependency2 {
29628     pub s_type: StructureType,
29629     pub p_next: *const c_void,
29630     pub src_subpass: u32,
29631     pub dst_subpass: u32,
29632     pub src_stage_mask: PipelineStageFlags,
29633     pub dst_stage_mask: PipelineStageFlags,
29634     pub src_access_mask: AccessFlags,
29635     pub dst_access_mask: AccessFlags,
29636     pub dependency_flags: DependencyFlags,
29637     pub view_offset: i32,
29638 }
29639 impl ::std::default::Default for SubpassDependency2 {
default() -> SubpassDependency229640     fn default() -> SubpassDependency2 {
29641         SubpassDependency2 {
29642             s_type: StructureType::SUBPASS_DEPENDENCY_2,
29643             p_next: ::std::ptr::null(),
29644             src_subpass: u32::default(),
29645             dst_subpass: u32::default(),
29646             src_stage_mask: PipelineStageFlags::default(),
29647             dst_stage_mask: PipelineStageFlags::default(),
29648             src_access_mask: AccessFlags::default(),
29649             dst_access_mask: AccessFlags::default(),
29650             dependency_flags: DependencyFlags::default(),
29651             view_offset: i32::default(),
29652         }
29653     }
29654 }
29655 impl SubpassDependency2 {
builder<'a>() -> SubpassDependency2Builder<'a>29656     pub fn builder<'a>() -> SubpassDependency2Builder<'a> {
29657         SubpassDependency2Builder {
29658             inner: SubpassDependency2::default(),
29659             marker: ::std::marker::PhantomData,
29660         }
29661     }
29662 }
29663 #[repr(transparent)]
29664 pub struct SubpassDependency2Builder<'a> {
29665     inner: SubpassDependency2,
29666     marker: ::std::marker::PhantomData<&'a ()>,
29667 }
29668 pub unsafe trait ExtendsSubpassDependency2 {}
29669 impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> {
29670     type Target = SubpassDependency2;
deref(&self) -> &Self::Target29671     fn deref(&self) -> &Self::Target {
29672         &self.inner
29673     }
29674 }
29675 impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target29676     fn deref_mut(&mut self) -> &mut Self::Target {
29677         &mut self.inner
29678     }
29679 }
29680 impl<'a> SubpassDependency2Builder<'a> {
src_subpass(mut self, src_subpass: u32) -> SubpassDependency2Builder<'a>29681     pub fn src_subpass(mut self, src_subpass: u32) -> SubpassDependency2Builder<'a> {
29682         self.inner.src_subpass = src_subpass;
29683         self
29684     }
dst_subpass(mut self, dst_subpass: u32) -> SubpassDependency2Builder<'a>29685     pub fn dst_subpass(mut self, dst_subpass: u32) -> SubpassDependency2Builder<'a> {
29686         self.inner.dst_subpass = dst_subpass;
29687         self
29688     }
src_stage_mask( mut self, src_stage_mask: PipelineStageFlags, ) -> SubpassDependency2Builder<'a>29689     pub fn src_stage_mask(
29690         mut self,
29691         src_stage_mask: PipelineStageFlags,
29692     ) -> SubpassDependency2Builder<'a> {
29693         self.inner.src_stage_mask = src_stage_mask;
29694         self
29695     }
dst_stage_mask( mut self, dst_stage_mask: PipelineStageFlags, ) -> SubpassDependency2Builder<'a>29696     pub fn dst_stage_mask(
29697         mut self,
29698         dst_stage_mask: PipelineStageFlags,
29699     ) -> SubpassDependency2Builder<'a> {
29700         self.inner.dst_stage_mask = dst_stage_mask;
29701         self
29702     }
src_access_mask( mut self, src_access_mask: AccessFlags, ) -> SubpassDependency2Builder<'a>29703     pub fn src_access_mask(
29704         mut self,
29705         src_access_mask: AccessFlags,
29706     ) -> SubpassDependency2Builder<'a> {
29707         self.inner.src_access_mask = src_access_mask;
29708         self
29709     }
dst_access_mask( mut self, dst_access_mask: AccessFlags, ) -> SubpassDependency2Builder<'a>29710     pub fn dst_access_mask(
29711         mut self,
29712         dst_access_mask: AccessFlags,
29713     ) -> SubpassDependency2Builder<'a> {
29714         self.inner.dst_access_mask = dst_access_mask;
29715         self
29716     }
dependency_flags( mut self, dependency_flags: DependencyFlags, ) -> SubpassDependency2Builder<'a>29717     pub fn dependency_flags(
29718         mut self,
29719         dependency_flags: DependencyFlags,
29720     ) -> SubpassDependency2Builder<'a> {
29721         self.inner.dependency_flags = dependency_flags;
29722         self
29723     }
view_offset(mut self, view_offset: i32) -> SubpassDependency2Builder<'a>29724     pub fn view_offset(mut self, view_offset: i32) -> SubpassDependency2Builder<'a> {
29725         self.inner.view_offset = view_offset;
29726         self
29727     }
29728     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
29729     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
29730     #[doc = r" valid extension structs can be pushed into the chain."]
29731     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
29732     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubpassDependency2>( mut self, next: &'a mut T, ) -> SubpassDependency2Builder<'a>29733     pub fn push_next<T: ExtendsSubpassDependency2>(
29734         mut self,
29735         next: &'a mut T,
29736     ) -> SubpassDependency2Builder<'a> {
29737         unsafe {
29738             let next_ptr = next as *mut T as *mut BaseOutStructure;
29739             let last_next = ptr_chain_iter(next).last().unwrap();
29740             (*last_next).p_next = self.inner.p_next as _;
29741             self.inner.p_next = next_ptr as _;
29742         }
29743         self
29744     }
29745     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29746     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29747     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDependency229748     pub fn build(self) -> SubpassDependency2 {
29749         self.inner
29750     }
29751 }
29752 #[repr(C)]
29753 #[derive(Copy, Clone, Debug)]
29754 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateInfo2.html>"]
29755 pub struct RenderPassCreateInfo2 {
29756     pub s_type: StructureType,
29757     pub p_next: *const c_void,
29758     pub flags: RenderPassCreateFlags,
29759     pub attachment_count: u32,
29760     pub p_attachments: *const AttachmentDescription2,
29761     pub subpass_count: u32,
29762     pub p_subpasses: *const SubpassDescription2,
29763     pub dependency_count: u32,
29764     pub p_dependencies: *const SubpassDependency2,
29765     pub correlated_view_mask_count: u32,
29766     pub p_correlated_view_masks: *const u32,
29767 }
29768 impl ::std::default::Default for RenderPassCreateInfo2 {
default() -> RenderPassCreateInfo229769     fn default() -> RenderPassCreateInfo2 {
29770         RenderPassCreateInfo2 {
29771             s_type: StructureType::RENDER_PASS_CREATE_INFO_2,
29772             p_next: ::std::ptr::null(),
29773             flags: RenderPassCreateFlags::default(),
29774             attachment_count: u32::default(),
29775             p_attachments: ::std::ptr::null(),
29776             subpass_count: u32::default(),
29777             p_subpasses: ::std::ptr::null(),
29778             dependency_count: u32::default(),
29779             p_dependencies: ::std::ptr::null(),
29780             correlated_view_mask_count: u32::default(),
29781             p_correlated_view_masks: ::std::ptr::null(),
29782         }
29783     }
29784 }
29785 impl RenderPassCreateInfo2 {
builder<'a>() -> RenderPassCreateInfo2Builder<'a>29786     pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> {
29787         RenderPassCreateInfo2Builder {
29788             inner: RenderPassCreateInfo2::default(),
29789             marker: ::std::marker::PhantomData,
29790         }
29791     }
29792 }
29793 #[repr(transparent)]
29794 pub struct RenderPassCreateInfo2Builder<'a> {
29795     inner: RenderPassCreateInfo2,
29796     marker: ::std::marker::PhantomData<&'a ()>,
29797 }
29798 pub unsafe trait ExtendsRenderPassCreateInfo2 {}
29799 impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> {
29800     type Target = RenderPassCreateInfo2;
deref(&self) -> &Self::Target29801     fn deref(&self) -> &Self::Target {
29802         &self.inner
29803     }
29804 }
29805 impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> {
deref_mut(&mut self) -> &mut Self::Target29806     fn deref_mut(&mut self) -> &mut Self::Target {
29807         &mut self.inner
29808     }
29809 }
29810 impl<'a> RenderPassCreateInfo2Builder<'a> {
flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfo2Builder<'a>29811     pub fn flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfo2Builder<'a> {
29812         self.inner.flags = flags;
29813         self
29814     }
attachments( mut self, attachments: &'a [AttachmentDescription2], ) -> RenderPassCreateInfo2Builder<'a>29815     pub fn attachments(
29816         mut self,
29817         attachments: &'a [AttachmentDescription2],
29818     ) -> RenderPassCreateInfo2Builder<'a> {
29819         self.inner.attachment_count = attachments.len() as _;
29820         self.inner.p_attachments = attachments.as_ptr();
29821         self
29822     }
subpasses( mut self, subpasses: &'a [SubpassDescription2], ) -> RenderPassCreateInfo2Builder<'a>29823     pub fn subpasses(
29824         mut self,
29825         subpasses: &'a [SubpassDescription2],
29826     ) -> RenderPassCreateInfo2Builder<'a> {
29827         self.inner.subpass_count = subpasses.len() as _;
29828         self.inner.p_subpasses = subpasses.as_ptr();
29829         self
29830     }
dependencies( mut self, dependencies: &'a [SubpassDependency2], ) -> RenderPassCreateInfo2Builder<'a>29831     pub fn dependencies(
29832         mut self,
29833         dependencies: &'a [SubpassDependency2],
29834     ) -> RenderPassCreateInfo2Builder<'a> {
29835         self.inner.dependency_count = dependencies.len() as _;
29836         self.inner.p_dependencies = dependencies.as_ptr();
29837         self
29838     }
correlated_view_masks( mut self, correlated_view_masks: &'a [u32], ) -> RenderPassCreateInfo2Builder<'a>29839     pub fn correlated_view_masks(
29840         mut self,
29841         correlated_view_masks: &'a [u32],
29842     ) -> RenderPassCreateInfo2Builder<'a> {
29843         self.inner.correlated_view_mask_count = correlated_view_masks.len() as _;
29844         self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr();
29845         self
29846     }
29847     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
29848     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
29849     #[doc = r" valid extension structs can be pushed into the chain."]
29850     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
29851     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRenderPassCreateInfo2>( mut self, next: &'a mut T, ) -> RenderPassCreateInfo2Builder<'a>29852     pub fn push_next<T: ExtendsRenderPassCreateInfo2>(
29853         mut self,
29854         next: &'a mut T,
29855     ) -> RenderPassCreateInfo2Builder<'a> {
29856         unsafe {
29857             let next_ptr = next as *mut T as *mut BaseOutStructure;
29858             let last_next = ptr_chain_iter(next).last().unwrap();
29859             (*last_next).p_next = self.inner.p_next as _;
29860             self.inner.p_next = next_ptr as _;
29861         }
29862         self
29863     }
29864     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29865     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29866     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassCreateInfo229867     pub fn build(self) -> RenderPassCreateInfo2 {
29868         self.inner
29869     }
29870 }
29871 #[repr(C)]
29872 #[derive(Copy, Clone, Debug)]
29873 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassBeginInfo.html>"]
29874 pub struct SubpassBeginInfo {
29875     pub s_type: StructureType,
29876     pub p_next: *const c_void,
29877     pub contents: SubpassContents,
29878 }
29879 impl ::std::default::Default for SubpassBeginInfo {
default() -> SubpassBeginInfo29880     fn default() -> SubpassBeginInfo {
29881         SubpassBeginInfo {
29882             s_type: StructureType::SUBPASS_BEGIN_INFO,
29883             p_next: ::std::ptr::null(),
29884             contents: SubpassContents::default(),
29885         }
29886     }
29887 }
29888 impl SubpassBeginInfo {
builder<'a>() -> SubpassBeginInfoBuilder<'a>29889     pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> {
29890         SubpassBeginInfoBuilder {
29891             inner: SubpassBeginInfo::default(),
29892             marker: ::std::marker::PhantomData,
29893         }
29894     }
29895 }
29896 #[repr(transparent)]
29897 pub struct SubpassBeginInfoBuilder<'a> {
29898     inner: SubpassBeginInfo,
29899     marker: ::std::marker::PhantomData<&'a ()>,
29900 }
29901 pub unsafe trait ExtendsSubpassBeginInfo {}
29902 impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> {
29903     type Target = SubpassBeginInfo;
deref(&self) -> &Self::Target29904     fn deref(&self) -> &Self::Target {
29905         &self.inner
29906     }
29907 }
29908 impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29909     fn deref_mut(&mut self) -> &mut Self::Target {
29910         &mut self.inner
29911     }
29912 }
29913 impl<'a> SubpassBeginInfoBuilder<'a> {
contents(mut self, contents: SubpassContents) -> SubpassBeginInfoBuilder<'a>29914     pub fn contents(mut self, contents: SubpassContents) -> SubpassBeginInfoBuilder<'a> {
29915         self.inner.contents = contents;
29916         self
29917     }
29918     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
29919     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
29920     #[doc = r" valid extension structs can be pushed into the chain."]
29921     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
29922     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubpassBeginInfo>( mut self, next: &'a mut T, ) -> SubpassBeginInfoBuilder<'a>29923     pub fn push_next<T: ExtendsSubpassBeginInfo>(
29924         mut self,
29925         next: &'a mut T,
29926     ) -> SubpassBeginInfoBuilder<'a> {
29927         unsafe {
29928             let next_ptr = next as *mut T as *mut BaseOutStructure;
29929             let last_next = ptr_chain_iter(next).last().unwrap();
29930             (*last_next).p_next = self.inner.p_next as _;
29931             self.inner.p_next = next_ptr as _;
29932         }
29933         self
29934     }
29935     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
29936     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
29937     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassBeginInfo29938     pub fn build(self) -> SubpassBeginInfo {
29939         self.inner
29940     }
29941 }
29942 #[repr(C)]
29943 #[derive(Copy, Clone, Debug)]
29944 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassEndInfo.html>"]
29945 pub struct SubpassEndInfo {
29946     pub s_type: StructureType,
29947     pub p_next: *const c_void,
29948 }
29949 impl ::std::default::Default for SubpassEndInfo {
default() -> SubpassEndInfo29950     fn default() -> SubpassEndInfo {
29951         SubpassEndInfo {
29952             s_type: StructureType::SUBPASS_END_INFO,
29953             p_next: ::std::ptr::null(),
29954         }
29955     }
29956 }
29957 impl SubpassEndInfo {
builder<'a>() -> SubpassEndInfoBuilder<'a>29958     pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> {
29959         SubpassEndInfoBuilder {
29960             inner: SubpassEndInfo::default(),
29961             marker: ::std::marker::PhantomData,
29962         }
29963     }
29964 }
29965 #[repr(transparent)]
29966 pub struct SubpassEndInfoBuilder<'a> {
29967     inner: SubpassEndInfo,
29968     marker: ::std::marker::PhantomData<&'a ()>,
29969 }
29970 pub unsafe trait ExtendsSubpassEndInfo {}
29971 impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> {
29972     type Target = SubpassEndInfo;
deref(&self) -> &Self::Target29973     fn deref(&self) -> &Self::Target {
29974         &self.inner
29975     }
29976 }
29977 impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target29978     fn deref_mut(&mut self) -> &mut Self::Target {
29979         &mut self.inner
29980     }
29981 }
29982 impl<'a> SubpassEndInfoBuilder<'a> {
29983     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
29984     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
29985     #[doc = r" valid extension structs can be pushed into the chain."]
29986     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
29987     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSubpassEndInfo>( mut self, next: &'a mut T, ) -> SubpassEndInfoBuilder<'a>29988     pub fn push_next<T: ExtendsSubpassEndInfo>(
29989         mut self,
29990         next: &'a mut T,
29991     ) -> SubpassEndInfoBuilder<'a> {
29992         unsafe {
29993             let next_ptr = next as *mut T as *mut BaseOutStructure;
29994             let last_next = ptr_chain_iter(next).last().unwrap();
29995             (*last_next).p_next = self.inner.p_next as _;
29996             self.inner.p_next = next_ptr as _;
29997         }
29998         self
29999     }
30000     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30001     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30002     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassEndInfo30003     pub fn build(self) -> SubpassEndInfo {
30004         self.inner
30005     }
30006 }
30007 #[repr(C)]
30008 #[derive(Copy, Clone, Debug)]
30009 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>"]
30010 pub struct PhysicalDeviceTimelineSemaphoreFeatures {
30011     pub s_type: StructureType,
30012     pub p_next: *mut c_void,
30013     pub timeline_semaphore: Bool32,
30014 }
30015 impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures {
default() -> PhysicalDeviceTimelineSemaphoreFeatures30016     fn default() -> PhysicalDeviceTimelineSemaphoreFeatures {
30017         PhysicalDeviceTimelineSemaphoreFeatures {
30018             s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
30019             p_next: ::std::ptr::null_mut(),
30020             timeline_semaphore: Bool32::default(),
30021         }
30022     }
30023 }
30024 impl PhysicalDeviceTimelineSemaphoreFeatures {
builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a>30025     pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30026         PhysicalDeviceTimelineSemaphoreFeaturesBuilder {
30027             inner: PhysicalDeviceTimelineSemaphoreFeatures::default(),
30028             marker: ::std::marker::PhantomData,
30029         }
30030     }
30031 }
30032 #[repr(transparent)]
30033 pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30034     inner: PhysicalDeviceTimelineSemaphoreFeatures,
30035     marker: ::std::marker::PhantomData<&'a ()>,
30036 }
30037 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
30038 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {}
30039 impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30040     type Target = PhysicalDeviceTimelineSemaphoreFeatures;
deref(&self) -> &Self::Target30041     fn deref(&self) -> &Self::Target {
30042         &self.inner
30043     }
30044 }
30045 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30046     fn deref_mut(&mut self) -> &mut Self::Target {
30047         &mut self.inner
30048     }
30049 }
30050 impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
timeline_semaphore( mut self, timeline_semaphore: bool, ) -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a>30051     pub fn timeline_semaphore(
30052         mut self,
30053         timeline_semaphore: bool,
30054     ) -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
30055         self.inner.timeline_semaphore = timeline_semaphore.into();
30056         self
30057     }
30058     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30059     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30060     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTimelineSemaphoreFeatures30061     pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures {
30062         self.inner
30063     }
30064 }
30065 #[repr(C)]
30066 #[derive(Copy, Clone, Debug)]
30067 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>"]
30068 pub struct PhysicalDeviceTimelineSemaphoreProperties {
30069     pub s_type: StructureType,
30070     pub p_next: *mut c_void,
30071     pub max_timeline_semaphore_value_difference: u64,
30072 }
30073 impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties {
default() -> PhysicalDeviceTimelineSemaphoreProperties30074     fn default() -> PhysicalDeviceTimelineSemaphoreProperties {
30075         PhysicalDeviceTimelineSemaphoreProperties {
30076             s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
30077             p_next: ::std::ptr::null_mut(),
30078             max_timeline_semaphore_value_difference: u64::default(),
30079         }
30080     }
30081 }
30082 impl PhysicalDeviceTimelineSemaphoreProperties {
builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a>30083     pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
30084         PhysicalDeviceTimelineSemaphorePropertiesBuilder {
30085             inner: PhysicalDeviceTimelineSemaphoreProperties::default(),
30086             marker: ::std::marker::PhantomData,
30087         }
30088     }
30089 }
30090 #[repr(transparent)]
30091 pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
30092     inner: PhysicalDeviceTimelineSemaphoreProperties,
30093     marker: ::std::marker::PhantomData<&'a ()>,
30094 }
30095 unsafe impl ExtendsPhysicalDeviceProperties2
30096     for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_>
30097 {
30098 }
30099 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {}
30100 impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
30101     type Target = PhysicalDeviceTimelineSemaphoreProperties;
deref(&self) -> &Self::Target30102     fn deref(&self) -> &Self::Target {
30103         &self.inner
30104     }
30105 }
30106 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30107     fn deref_mut(&mut self) -> &mut Self::Target {
30108         &mut self.inner
30109     }
30110 }
30111 impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
max_timeline_semaphore_value_difference( mut self, max_timeline_semaphore_value_difference: u64, ) -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a>30112     pub fn max_timeline_semaphore_value_difference(
30113         mut self,
30114         max_timeline_semaphore_value_difference: u64,
30115     ) -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
30116         self.inner.max_timeline_semaphore_value_difference =
30117             max_timeline_semaphore_value_difference;
30118         self
30119     }
30120     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30121     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30122     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTimelineSemaphoreProperties30123     pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties {
30124         self.inner
30125     }
30126 }
30127 #[repr(C)]
30128 #[derive(Copy, Clone, Debug)]
30129 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreTypeCreateInfo.html>"]
30130 pub struct SemaphoreTypeCreateInfo {
30131     pub s_type: StructureType,
30132     pub p_next: *const c_void,
30133     pub semaphore_type: SemaphoreType,
30134     pub initial_value: u64,
30135 }
30136 impl ::std::default::Default for SemaphoreTypeCreateInfo {
default() -> SemaphoreTypeCreateInfo30137     fn default() -> SemaphoreTypeCreateInfo {
30138         SemaphoreTypeCreateInfo {
30139             s_type: StructureType::SEMAPHORE_TYPE_CREATE_INFO,
30140             p_next: ::std::ptr::null(),
30141             semaphore_type: SemaphoreType::default(),
30142             initial_value: u64::default(),
30143         }
30144     }
30145 }
30146 impl SemaphoreTypeCreateInfo {
builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a>30147     pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> {
30148         SemaphoreTypeCreateInfoBuilder {
30149             inner: SemaphoreTypeCreateInfo::default(),
30150             marker: ::std::marker::PhantomData,
30151         }
30152     }
30153 }
30154 #[repr(transparent)]
30155 pub struct SemaphoreTypeCreateInfoBuilder<'a> {
30156     inner: SemaphoreTypeCreateInfo,
30157     marker: ::std::marker::PhantomData<&'a ()>,
30158 }
30159 unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
30160 unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {}
30161 unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
30162 unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {}
30163 impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> {
30164     type Target = SemaphoreTypeCreateInfo;
deref(&self) -> &Self::Target30165     fn deref(&self) -> &Self::Target {
30166         &self.inner
30167     }
30168 }
30169 impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30170     fn deref_mut(&mut self) -> &mut Self::Target {
30171         &mut self.inner
30172     }
30173 }
30174 impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
semaphore_type( mut self, semaphore_type: SemaphoreType, ) -> SemaphoreTypeCreateInfoBuilder<'a>30175     pub fn semaphore_type(
30176         mut self,
30177         semaphore_type: SemaphoreType,
30178     ) -> SemaphoreTypeCreateInfoBuilder<'a> {
30179         self.inner.semaphore_type = semaphore_type;
30180         self
30181     }
initial_value(mut self, initial_value: u64) -> SemaphoreTypeCreateInfoBuilder<'a>30182     pub fn initial_value(mut self, initial_value: u64) -> SemaphoreTypeCreateInfoBuilder<'a> {
30183         self.inner.initial_value = initial_value;
30184         self
30185     }
30186     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30187     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30188     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreTypeCreateInfo30189     pub fn build(self) -> SemaphoreTypeCreateInfo {
30190         self.inner
30191     }
30192 }
30193 #[repr(C)]
30194 #[derive(Copy, Clone, Debug)]
30195 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html>"]
30196 pub struct TimelineSemaphoreSubmitInfo {
30197     pub s_type: StructureType,
30198     pub p_next: *const c_void,
30199     pub wait_semaphore_value_count: u32,
30200     pub p_wait_semaphore_values: *const u64,
30201     pub signal_semaphore_value_count: u32,
30202     pub p_signal_semaphore_values: *const u64,
30203 }
30204 impl ::std::default::Default for TimelineSemaphoreSubmitInfo {
default() -> TimelineSemaphoreSubmitInfo30205     fn default() -> TimelineSemaphoreSubmitInfo {
30206         TimelineSemaphoreSubmitInfo {
30207             s_type: StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO,
30208             p_next: ::std::ptr::null(),
30209             wait_semaphore_value_count: u32::default(),
30210             p_wait_semaphore_values: ::std::ptr::null(),
30211             signal_semaphore_value_count: u32::default(),
30212             p_signal_semaphore_values: ::std::ptr::null(),
30213         }
30214     }
30215 }
30216 impl TimelineSemaphoreSubmitInfo {
builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a>30217     pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> {
30218         TimelineSemaphoreSubmitInfoBuilder {
30219             inner: TimelineSemaphoreSubmitInfo::default(),
30220             marker: ::std::marker::PhantomData,
30221         }
30222     }
30223 }
30224 #[repr(transparent)]
30225 pub struct TimelineSemaphoreSubmitInfoBuilder<'a> {
30226     inner: TimelineSemaphoreSubmitInfo,
30227     marker: ::std::marker::PhantomData<&'a ()>,
30228 }
30229 unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
30230 unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {}
30231 unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
30232 unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {}
30233 impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> {
30234     type Target = TimelineSemaphoreSubmitInfo;
deref(&self) -> &Self::Target30235     fn deref(&self) -> &Self::Target {
30236         &self.inner
30237     }
30238 }
30239 impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30240     fn deref_mut(&mut self) -> &mut Self::Target {
30241         &mut self.inner
30242     }
30243 }
30244 impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
wait_semaphore_values( mut self, wait_semaphore_values: &'a [u64], ) -> TimelineSemaphoreSubmitInfoBuilder<'a>30245     pub fn wait_semaphore_values(
30246         mut self,
30247         wait_semaphore_values: &'a [u64],
30248     ) -> TimelineSemaphoreSubmitInfoBuilder<'a> {
30249         self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _;
30250         self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
30251         self
30252     }
signal_semaphore_values( mut self, signal_semaphore_values: &'a [u64], ) -> TimelineSemaphoreSubmitInfoBuilder<'a>30253     pub fn signal_semaphore_values(
30254         mut self,
30255         signal_semaphore_values: &'a [u64],
30256     ) -> TimelineSemaphoreSubmitInfoBuilder<'a> {
30257         self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _;
30258         self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
30259         self
30260     }
30261     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30262     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30263     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TimelineSemaphoreSubmitInfo30264     pub fn build(self) -> TimelineSemaphoreSubmitInfo {
30265         self.inner
30266     }
30267 }
30268 #[repr(C)]
30269 #[derive(Copy, Clone, Debug)]
30270 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitInfo.html>"]
30271 pub struct SemaphoreWaitInfo {
30272     pub s_type: StructureType,
30273     pub p_next: *const c_void,
30274     pub flags: SemaphoreWaitFlags,
30275     pub semaphore_count: u32,
30276     pub p_semaphores: *const Semaphore,
30277     pub p_values: *const u64,
30278 }
30279 impl ::std::default::Default for SemaphoreWaitInfo {
default() -> SemaphoreWaitInfo30280     fn default() -> SemaphoreWaitInfo {
30281         SemaphoreWaitInfo {
30282             s_type: StructureType::SEMAPHORE_WAIT_INFO,
30283             p_next: ::std::ptr::null(),
30284             flags: SemaphoreWaitFlags::default(),
30285             semaphore_count: u32::default(),
30286             p_semaphores: ::std::ptr::null(),
30287             p_values: ::std::ptr::null(),
30288         }
30289     }
30290 }
30291 impl SemaphoreWaitInfo {
builder<'a>() -> SemaphoreWaitInfoBuilder<'a>30292     pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> {
30293         SemaphoreWaitInfoBuilder {
30294             inner: SemaphoreWaitInfo::default(),
30295             marker: ::std::marker::PhantomData,
30296         }
30297     }
30298 }
30299 #[repr(transparent)]
30300 pub struct SemaphoreWaitInfoBuilder<'a> {
30301     inner: SemaphoreWaitInfo,
30302     marker: ::std::marker::PhantomData<&'a ()>,
30303 }
30304 pub unsafe trait ExtendsSemaphoreWaitInfo {}
30305 impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> {
30306     type Target = SemaphoreWaitInfo;
deref(&self) -> &Self::Target30307     fn deref(&self) -> &Self::Target {
30308         &self.inner
30309     }
30310 }
30311 impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30312     fn deref_mut(&mut self) -> &mut Self::Target {
30313         &mut self.inner
30314     }
30315 }
30316 impl<'a> SemaphoreWaitInfoBuilder<'a> {
flags(mut self, flags: SemaphoreWaitFlags) -> SemaphoreWaitInfoBuilder<'a>30317     pub fn flags(mut self, flags: SemaphoreWaitFlags) -> SemaphoreWaitInfoBuilder<'a> {
30318         self.inner.flags = flags;
30319         self
30320     }
semaphores(mut self, semaphores: &'a [Semaphore]) -> SemaphoreWaitInfoBuilder<'a>30321     pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> SemaphoreWaitInfoBuilder<'a> {
30322         self.inner.semaphore_count = semaphores.len() as _;
30323         self.inner.p_semaphores = semaphores.as_ptr();
30324         self
30325     }
values(mut self, values: &'a [u64]) -> SemaphoreWaitInfoBuilder<'a>30326     pub fn values(mut self, values: &'a [u64]) -> SemaphoreWaitInfoBuilder<'a> {
30327         self.inner.semaphore_count = values.len() as _;
30328         self.inner.p_values = values.as_ptr();
30329         self
30330     }
30331     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30332     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30333     #[doc = r" valid extension structs can be pushed into the chain."]
30334     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30335     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSemaphoreWaitInfo>( mut self, next: &'a mut T, ) -> SemaphoreWaitInfoBuilder<'a>30336     pub fn push_next<T: ExtendsSemaphoreWaitInfo>(
30337         mut self,
30338         next: &'a mut T,
30339     ) -> SemaphoreWaitInfoBuilder<'a> {
30340         unsafe {
30341             let next_ptr = next as *mut T as *mut BaseOutStructure;
30342             let last_next = ptr_chain_iter(next).last().unwrap();
30343             (*last_next).p_next = self.inner.p_next as _;
30344             self.inner.p_next = next_ptr as _;
30345         }
30346         self
30347     }
30348     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30349     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30350     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreWaitInfo30351     pub fn build(self) -> SemaphoreWaitInfo {
30352         self.inner
30353     }
30354 }
30355 #[repr(C)]
30356 #[derive(Copy, Clone, Debug)]
30357 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreSignalInfo.html>"]
30358 pub struct SemaphoreSignalInfo {
30359     pub s_type: StructureType,
30360     pub p_next: *const c_void,
30361     pub semaphore: Semaphore,
30362     pub value: u64,
30363 }
30364 impl ::std::default::Default for SemaphoreSignalInfo {
default() -> SemaphoreSignalInfo30365     fn default() -> SemaphoreSignalInfo {
30366         SemaphoreSignalInfo {
30367             s_type: StructureType::SEMAPHORE_SIGNAL_INFO,
30368             p_next: ::std::ptr::null(),
30369             semaphore: Semaphore::default(),
30370             value: u64::default(),
30371         }
30372     }
30373 }
30374 impl SemaphoreSignalInfo {
builder<'a>() -> SemaphoreSignalInfoBuilder<'a>30375     pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> {
30376         SemaphoreSignalInfoBuilder {
30377             inner: SemaphoreSignalInfo::default(),
30378             marker: ::std::marker::PhantomData,
30379         }
30380     }
30381 }
30382 #[repr(transparent)]
30383 pub struct SemaphoreSignalInfoBuilder<'a> {
30384     inner: SemaphoreSignalInfo,
30385     marker: ::std::marker::PhantomData<&'a ()>,
30386 }
30387 pub unsafe trait ExtendsSemaphoreSignalInfo {}
30388 impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> {
30389     type Target = SemaphoreSignalInfo;
deref(&self) -> &Self::Target30390     fn deref(&self) -> &Self::Target {
30391         &self.inner
30392     }
30393 }
30394 impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30395     fn deref_mut(&mut self) -> &mut Self::Target {
30396         &mut self.inner
30397     }
30398 }
30399 impl<'a> SemaphoreSignalInfoBuilder<'a> {
semaphore(mut self, semaphore: Semaphore) -> SemaphoreSignalInfoBuilder<'a>30400     pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreSignalInfoBuilder<'a> {
30401         self.inner.semaphore = semaphore;
30402         self
30403     }
value(mut self, value: u64) -> SemaphoreSignalInfoBuilder<'a>30404     pub fn value(mut self, value: u64) -> SemaphoreSignalInfoBuilder<'a> {
30405         self.inner.value = value;
30406         self
30407     }
30408     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30409     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30410     #[doc = r" valid extension structs can be pushed into the chain."]
30411     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30412     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsSemaphoreSignalInfo>( mut self, next: &'a mut T, ) -> SemaphoreSignalInfoBuilder<'a>30413     pub fn push_next<T: ExtendsSemaphoreSignalInfo>(
30414         mut self,
30415         next: &'a mut T,
30416     ) -> SemaphoreSignalInfoBuilder<'a> {
30417         unsafe {
30418             let next_ptr = next as *mut T as *mut BaseOutStructure;
30419             let last_next = ptr_chain_iter(next).last().unwrap();
30420             (*last_next).p_next = self.inner.p_next as _;
30421             self.inner.p_next = next_ptr as _;
30422         }
30423         self
30424     }
30425     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30426     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30427     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SemaphoreSignalInfo30428     pub fn build(self) -> SemaphoreSignalInfo {
30429         self.inner
30430     }
30431 }
30432 #[repr(C)]
30433 #[derive(Copy, Clone, Default, Debug)]
30434 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>"]
30435 pub struct VertexInputBindingDivisorDescriptionEXT {
30436     pub binding: u32,
30437     pub divisor: u32,
30438 }
30439 impl VertexInputBindingDivisorDescriptionEXT {
builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a>30440     pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
30441         VertexInputBindingDivisorDescriptionEXTBuilder {
30442             inner: VertexInputBindingDivisorDescriptionEXT::default(),
30443             marker: ::std::marker::PhantomData,
30444         }
30445     }
30446 }
30447 #[repr(transparent)]
30448 pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
30449     inner: VertexInputBindingDivisorDescriptionEXT,
30450     marker: ::std::marker::PhantomData<&'a ()>,
30451 }
30452 impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
30453     type Target = VertexInputBindingDivisorDescriptionEXT;
deref(&self) -> &Self::Target30454     fn deref(&self) -> &Self::Target {
30455         &self.inner
30456     }
30457 }
30458 impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30459     fn deref_mut(&mut self) -> &mut Self::Target {
30460         &mut self.inner
30461     }
30462 }
30463 impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
binding(mut self, binding: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a>30464     pub fn binding(mut self, binding: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
30465         self.inner.binding = binding;
30466         self
30467     }
divisor(mut self, divisor: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a>30468     pub fn divisor(mut self, divisor: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
30469         self.inner.divisor = divisor;
30470         self
30471     }
30472     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30473     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30474     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> VertexInputBindingDivisorDescriptionEXT30475     pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT {
30476         self.inner
30477     }
30478 }
30479 #[repr(C)]
30480 #[derive(Copy, Clone, Debug)]
30481 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>"]
30482 pub struct PipelineVertexInputDivisorStateCreateInfoEXT {
30483     pub s_type: StructureType,
30484     pub p_next: *const c_void,
30485     pub vertex_binding_divisor_count: u32,
30486     pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT,
30487 }
30488 impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT {
default() -> PipelineVertexInputDivisorStateCreateInfoEXT30489     fn default() -> PipelineVertexInputDivisorStateCreateInfoEXT {
30490         PipelineVertexInputDivisorStateCreateInfoEXT {
30491             s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
30492             p_next: ::std::ptr::null(),
30493             vertex_binding_divisor_count: u32::default(),
30494             p_vertex_binding_divisors: ::std::ptr::null(),
30495         }
30496     }
30497 }
30498 impl PipelineVertexInputDivisorStateCreateInfoEXT {
builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a>30499     pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
30500         PipelineVertexInputDivisorStateCreateInfoEXTBuilder {
30501             inner: PipelineVertexInputDivisorStateCreateInfoEXT::default(),
30502             marker: ::std::marker::PhantomData,
30503         }
30504     }
30505 }
30506 #[repr(transparent)]
30507 pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
30508     inner: PipelineVertexInputDivisorStateCreateInfoEXT,
30509     marker: ::std::marker::PhantomData<&'a ()>,
30510 }
30511 unsafe impl ExtendsPipelineVertexInputStateCreateInfo
30512     for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_>
30513 {
30514 }
30515 unsafe impl ExtendsPipelineVertexInputStateCreateInfo
30516     for PipelineVertexInputDivisorStateCreateInfoEXT
30517 {
30518 }
30519 impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
30520     type Target = PipelineVertexInputDivisorStateCreateInfoEXT;
deref(&self) -> &Self::Target30521     fn deref(&self) -> &Self::Target {
30522         &self.inner
30523     }
30524 }
30525 impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30526     fn deref_mut(&mut self) -> &mut Self::Target {
30527         &mut self.inner
30528     }
30529 }
30530 impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
vertex_binding_divisors( mut self, vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT], ) -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a>30531     pub fn vertex_binding_divisors(
30532         mut self,
30533         vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT],
30534     ) -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
30535         self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _;
30536         self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr();
30537         self
30538     }
30539     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30540     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30541     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT30542     pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT {
30543         self.inner
30544     }
30545 }
30546 #[repr(C)]
30547 #[derive(Copy, Clone, Debug)]
30548 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>"]
30549 pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
30550     pub s_type: StructureType,
30551     pub p_next: *mut c_void,
30552     pub max_vertex_attrib_divisor: u32,
30553 }
30554 impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
default() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT30555     fn default() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
30556         PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
30557             s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
30558             p_next: ::std::ptr::null_mut(),
30559             max_vertex_attrib_divisor: u32::default(),
30560         }
30561     }
30562 }
30563 impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a>30564     pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
30565         PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder {
30566             inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT::default(),
30567             marker: ::std::marker::PhantomData,
30568         }
30569     }
30570 }
30571 #[repr(transparent)]
30572 pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
30573     inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT,
30574     marker: ::std::marker::PhantomData<&'a ()>,
30575 }
30576 unsafe impl ExtendsPhysicalDeviceProperties2
30577     for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_>
30578 {
30579 }
30580 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {}
30581 impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
30582     type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
deref(&self) -> &Self::Target30583     fn deref(&self) -> &Self::Target {
30584         &self.inner
30585     }
30586 }
30587 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30588     fn deref_mut(&mut self) -> &mut Self::Target {
30589         &mut self.inner
30590     }
30591 }
30592 impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
max_vertex_attrib_divisor( mut self, max_vertex_attrib_divisor: u32, ) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a>30593     pub fn max_vertex_attrib_divisor(
30594         mut self,
30595         max_vertex_attrib_divisor: u32,
30596     ) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
30597         self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor;
30598         self
30599     }
30600     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30601     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30602     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT30603     pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
30604         self.inner
30605     }
30606 }
30607 #[repr(C)]
30608 #[derive(Copy, Clone, Debug)]
30609 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>"]
30610 pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
30611     pub s_type: StructureType,
30612     pub p_next: *mut c_void,
30613     pub pci_domain: u32,
30614     pub pci_bus: u32,
30615     pub pci_device: u32,
30616     pub pci_function: u32,
30617 }
30618 impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT {
default() -> PhysicalDevicePCIBusInfoPropertiesEXT30619     fn default() -> PhysicalDevicePCIBusInfoPropertiesEXT {
30620         PhysicalDevicePCIBusInfoPropertiesEXT {
30621             s_type: StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
30622             p_next: ::std::ptr::null_mut(),
30623             pci_domain: u32::default(),
30624             pci_bus: u32::default(),
30625             pci_device: u32::default(),
30626             pci_function: u32::default(),
30627         }
30628     }
30629 }
30630 impl PhysicalDevicePCIBusInfoPropertiesEXT {
builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a>30631     pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
30632         PhysicalDevicePCIBusInfoPropertiesEXTBuilder {
30633             inner: PhysicalDevicePCIBusInfoPropertiesEXT::default(),
30634             marker: ::std::marker::PhantomData,
30635         }
30636     }
30637 }
30638 #[repr(transparent)]
30639 pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
30640     inner: PhysicalDevicePCIBusInfoPropertiesEXT,
30641     marker: ::std::marker::PhantomData<&'a ()>,
30642 }
30643 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {}
30644 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {}
30645 impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
30646     type Target = PhysicalDevicePCIBusInfoPropertiesEXT;
deref(&self) -> &Self::Target30647     fn deref(&self) -> &Self::Target {
30648         &self.inner
30649     }
30650 }
30651 impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30652     fn deref_mut(&mut self) -> &mut Self::Target {
30653         &mut self.inner
30654     }
30655 }
30656 impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
pci_domain( mut self, pci_domain: u32, ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a>30657     pub fn pci_domain(
30658         mut self,
30659         pci_domain: u32,
30660     ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
30661         self.inner.pci_domain = pci_domain;
30662         self
30663     }
pci_bus(mut self, pci_bus: u32) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a>30664     pub fn pci_bus(mut self, pci_bus: u32) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
30665         self.inner.pci_bus = pci_bus;
30666         self
30667     }
pci_device( mut self, pci_device: u32, ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a>30668     pub fn pci_device(
30669         mut self,
30670         pci_device: u32,
30671     ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
30672         self.inner.pci_device = pci_device;
30673         self
30674     }
pci_function( mut self, pci_function: u32, ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a>30675     pub fn pci_function(
30676         mut self,
30677         pci_function: u32,
30678     ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
30679         self.inner.pci_function = pci_function;
30680         self
30681     }
30682     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30683     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30684     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT30685     pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT {
30686         self.inner
30687     }
30688 }
30689 #[repr(C)]
30690 #[derive(Copy, Clone, Debug)]
30691 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>"]
30692 pub struct ImportAndroidHardwareBufferInfoANDROID {
30693     pub s_type: StructureType,
30694     pub p_next: *const c_void,
30695     pub buffer: *mut AHardwareBuffer,
30696 }
30697 impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID {
default() -> ImportAndroidHardwareBufferInfoANDROID30698     fn default() -> ImportAndroidHardwareBufferInfoANDROID {
30699         ImportAndroidHardwareBufferInfoANDROID {
30700             s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
30701             p_next: ::std::ptr::null(),
30702             buffer: ::std::ptr::null_mut(),
30703         }
30704     }
30705 }
30706 impl ImportAndroidHardwareBufferInfoANDROID {
builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a>30707     pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30708         ImportAndroidHardwareBufferInfoANDROIDBuilder {
30709             inner: ImportAndroidHardwareBufferInfoANDROID::default(),
30710             marker: ::std::marker::PhantomData,
30711         }
30712     }
30713 }
30714 #[repr(transparent)]
30715 pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30716     inner: ImportAndroidHardwareBufferInfoANDROID,
30717     marker: ::std::marker::PhantomData<&'a ()>,
30718 }
30719 unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {}
30720 unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {}
30721 impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30722     type Target = ImportAndroidHardwareBufferInfoANDROID;
deref(&self) -> &Self::Target30723     fn deref(&self) -> &Self::Target {
30724         &self.inner
30725     }
30726 }
30727 impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30728     fn deref_mut(&mut self) -> &mut Self::Target {
30729         &mut self.inner
30730     }
30731 }
30732 impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
buffer( mut self, buffer: *mut AHardwareBuffer, ) -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a>30733     pub fn buffer(
30734         mut self,
30735         buffer: *mut AHardwareBuffer,
30736     ) -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30737         self.inner.buffer = buffer;
30738         self
30739     }
30740     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30741     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30742     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImportAndroidHardwareBufferInfoANDROID30743     pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID {
30744         self.inner
30745     }
30746 }
30747 #[repr(C)]
30748 #[derive(Copy, Clone, Debug)]
30749 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferUsageANDROID.html>"]
30750 pub struct AndroidHardwareBufferUsageANDROID {
30751     pub s_type: StructureType,
30752     pub p_next: *mut c_void,
30753     pub android_hardware_buffer_usage: u64,
30754 }
30755 impl ::std::default::Default for AndroidHardwareBufferUsageANDROID {
default() -> AndroidHardwareBufferUsageANDROID30756     fn default() -> AndroidHardwareBufferUsageANDROID {
30757         AndroidHardwareBufferUsageANDROID {
30758             s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
30759             p_next: ::std::ptr::null_mut(),
30760             android_hardware_buffer_usage: u64::default(),
30761         }
30762     }
30763 }
30764 impl AndroidHardwareBufferUsageANDROID {
builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a>30765     pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
30766         AndroidHardwareBufferUsageANDROIDBuilder {
30767             inner: AndroidHardwareBufferUsageANDROID::default(),
30768             marker: ::std::marker::PhantomData,
30769         }
30770     }
30771 }
30772 #[repr(transparent)]
30773 pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> {
30774     inner: AndroidHardwareBufferUsageANDROID,
30775     marker: ::std::marker::PhantomData<&'a ()>,
30776 }
30777 unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {}
30778 unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {}
30779 impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
30780     type Target = AndroidHardwareBufferUsageANDROID;
deref(&self) -> &Self::Target30781     fn deref(&self) -> &Self::Target {
30782         &self.inner
30783     }
30784 }
30785 impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30786     fn deref_mut(&mut self) -> &mut Self::Target {
30787         &mut self.inner
30788     }
30789 }
30790 impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
android_hardware_buffer_usage( mut self, android_hardware_buffer_usage: u64, ) -> AndroidHardwareBufferUsageANDROIDBuilder<'a>30791     pub fn android_hardware_buffer_usage(
30792         mut self,
30793         android_hardware_buffer_usage: u64,
30794     ) -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
30795         self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage;
30796         self
30797     }
30798     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30799     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30800     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidHardwareBufferUsageANDROID30801     pub fn build(self) -> AndroidHardwareBufferUsageANDROID {
30802         self.inner
30803     }
30804 }
30805 #[repr(C)]
30806 #[derive(Copy, Clone, Debug)]
30807 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>"]
30808 pub struct AndroidHardwareBufferPropertiesANDROID {
30809     pub s_type: StructureType,
30810     pub p_next: *mut c_void,
30811     pub allocation_size: DeviceSize,
30812     pub memory_type_bits: u32,
30813 }
30814 impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID {
default() -> AndroidHardwareBufferPropertiesANDROID30815     fn default() -> AndroidHardwareBufferPropertiesANDROID {
30816         AndroidHardwareBufferPropertiesANDROID {
30817             s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
30818             p_next: ::std::ptr::null_mut(),
30819             allocation_size: DeviceSize::default(),
30820             memory_type_bits: u32::default(),
30821         }
30822     }
30823 }
30824 impl AndroidHardwareBufferPropertiesANDROID {
builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a>30825     pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
30826         AndroidHardwareBufferPropertiesANDROIDBuilder {
30827             inner: AndroidHardwareBufferPropertiesANDROID::default(),
30828             marker: ::std::marker::PhantomData,
30829         }
30830     }
30831 }
30832 #[repr(transparent)]
30833 pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
30834     inner: AndroidHardwareBufferPropertiesANDROID,
30835     marker: ::std::marker::PhantomData<&'a ()>,
30836 }
30837 pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {}
30838 impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
30839     type Target = AndroidHardwareBufferPropertiesANDROID;
deref(&self) -> &Self::Target30840     fn deref(&self) -> &Self::Target {
30841         &self.inner
30842     }
30843 }
30844 impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30845     fn deref_mut(&mut self) -> &mut Self::Target {
30846         &mut self.inner
30847     }
30848 }
30849 impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
allocation_size( mut self, allocation_size: DeviceSize, ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a>30850     pub fn allocation_size(
30851         mut self,
30852         allocation_size: DeviceSize,
30853     ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
30854         self.inner.allocation_size = allocation_size;
30855         self
30856     }
memory_type_bits( mut self, memory_type_bits: u32, ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a>30857     pub fn memory_type_bits(
30858         mut self,
30859         memory_type_bits: u32,
30860     ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
30861         self.inner.memory_type_bits = memory_type_bits;
30862         self
30863     }
30864     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30865     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30866     #[doc = r" valid extension structs can be pushed into the chain."]
30867     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30868     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>( mut self, next: &'a mut T, ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a>30869     pub fn push_next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>(
30870         mut self,
30871         next: &'a mut T,
30872     ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
30873         unsafe {
30874             let next_ptr = next as *mut T as *mut BaseOutStructure;
30875             let last_next = ptr_chain_iter(next).last().unwrap();
30876             (*last_next).p_next = self.inner.p_next as _;
30877             self.inner.p_next = next_ptr as _;
30878         }
30879         self
30880     }
30881     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30882     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30883     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidHardwareBufferPropertiesANDROID30884     pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID {
30885         self.inner
30886     }
30887 }
30888 #[repr(C)]
30889 #[derive(Copy, Clone, Debug)]
30890 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>"]
30891 pub struct MemoryGetAndroidHardwareBufferInfoANDROID {
30892     pub s_type: StructureType,
30893     pub p_next: *const c_void,
30894     pub memory: DeviceMemory,
30895 }
30896 impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID {
default() -> MemoryGetAndroidHardwareBufferInfoANDROID30897     fn default() -> MemoryGetAndroidHardwareBufferInfoANDROID {
30898         MemoryGetAndroidHardwareBufferInfoANDROID {
30899             s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
30900             p_next: ::std::ptr::null(),
30901             memory: DeviceMemory::default(),
30902         }
30903     }
30904 }
30905 impl MemoryGetAndroidHardwareBufferInfoANDROID {
builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a>30906     pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30907         MemoryGetAndroidHardwareBufferInfoANDROIDBuilder {
30908             inner: MemoryGetAndroidHardwareBufferInfoANDROID::default(),
30909             marker: ::std::marker::PhantomData,
30910         }
30911     }
30912 }
30913 #[repr(transparent)]
30914 pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30915     inner: MemoryGetAndroidHardwareBufferInfoANDROID,
30916     marker: ::std::marker::PhantomData<&'a ()>,
30917 }
30918 pub unsafe trait ExtendsMemoryGetAndroidHardwareBufferInfoANDROID {}
30919 impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30920     type Target = MemoryGetAndroidHardwareBufferInfoANDROID;
deref(&self) -> &Self::Target30921     fn deref(&self) -> &Self::Target {
30922         &self.inner
30923     }
30924 }
30925 impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target30926     fn deref_mut(&mut self) -> &mut Self::Target {
30927         &mut self.inner
30928     }
30929 }
30930 impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
memory( mut self, memory: DeviceMemory, ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a>30931     pub fn memory(
30932         mut self,
30933         memory: DeviceMemory,
30934     ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30935         self.inner.memory = memory;
30936         self
30937     }
30938     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
30939     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
30940     #[doc = r" valid extension structs can be pushed into the chain."]
30941     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
30942     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsMemoryGetAndroidHardwareBufferInfoANDROID>( mut self, next: &'a mut T, ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a>30943     pub fn push_next<T: ExtendsMemoryGetAndroidHardwareBufferInfoANDROID>(
30944         mut self,
30945         next: &'a mut T,
30946     ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
30947         unsafe {
30948             let next_ptr = next as *mut T as *mut BaseOutStructure;
30949             let last_next = ptr_chain_iter(next).last().unwrap();
30950             (*last_next).p_next = self.inner.p_next as _;
30951             self.inner.p_next = next_ptr as _;
30952         }
30953         self
30954     }
30955     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
30956     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
30957     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID30958     pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID {
30959         self.inner
30960     }
30961 }
30962 #[repr(C)]
30963 #[derive(Copy, Clone, Debug)]
30964 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>"]
30965 pub struct AndroidHardwareBufferFormatPropertiesANDROID {
30966     pub s_type: StructureType,
30967     pub p_next: *mut c_void,
30968     pub format: Format,
30969     pub external_format: u64,
30970     pub format_features: FormatFeatureFlags,
30971     pub sampler_ycbcr_conversion_components: ComponentMapping,
30972     pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
30973     pub suggested_ycbcr_range: SamplerYcbcrRange,
30974     pub suggested_x_chroma_offset: ChromaLocation,
30975     pub suggested_y_chroma_offset: ChromaLocation,
30976 }
30977 impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID {
default() -> AndroidHardwareBufferFormatPropertiesANDROID30978     fn default() -> AndroidHardwareBufferFormatPropertiesANDROID {
30979         AndroidHardwareBufferFormatPropertiesANDROID {
30980             s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
30981             p_next: ::std::ptr::null_mut(),
30982             format: Format::default(),
30983             external_format: u64::default(),
30984             format_features: FormatFeatureFlags::default(),
30985             sampler_ycbcr_conversion_components: ComponentMapping::default(),
30986             suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
30987             suggested_ycbcr_range: SamplerYcbcrRange::default(),
30988             suggested_x_chroma_offset: ChromaLocation::default(),
30989             suggested_y_chroma_offset: ChromaLocation::default(),
30990         }
30991     }
30992 }
30993 impl AndroidHardwareBufferFormatPropertiesANDROID {
builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>30994     pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
30995         AndroidHardwareBufferFormatPropertiesANDROIDBuilder {
30996             inner: AndroidHardwareBufferFormatPropertiesANDROID::default(),
30997             marker: ::std::marker::PhantomData,
30998         }
30999     }
31000 }
31001 #[repr(transparent)]
31002 pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31003     inner: AndroidHardwareBufferFormatPropertiesANDROID,
31004     marker: ::std::marker::PhantomData<&'a ()>,
31005 }
31006 unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
31007     for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_>
31008 {
31009 }
31010 unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
31011     for AndroidHardwareBufferFormatPropertiesANDROID
31012 {
31013 }
31014 impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31015     type Target = AndroidHardwareBufferFormatPropertiesANDROID;
deref(&self) -> &Self::Target31016     fn deref(&self) -> &Self::Target {
31017         &self.inner
31018     }
31019 }
31020 impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31021     fn deref_mut(&mut self) -> &mut Self::Target {
31022         &mut self.inner
31023     }
31024 }
31025 impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
format( mut self, format: Format, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31026     pub fn format(
31027         mut self,
31028         format: Format,
31029     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31030         self.inner.format = format;
31031         self
31032     }
external_format( mut self, external_format: u64, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31033     pub fn external_format(
31034         mut self,
31035         external_format: u64,
31036     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31037         self.inner.external_format = external_format;
31038         self
31039     }
format_features( mut self, format_features: FormatFeatureFlags, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31040     pub fn format_features(
31041         mut self,
31042         format_features: FormatFeatureFlags,
31043     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31044         self.inner.format_features = format_features;
31045         self
31046     }
sampler_ycbcr_conversion_components( mut self, sampler_ycbcr_conversion_components: ComponentMapping, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31047     pub fn sampler_ycbcr_conversion_components(
31048         mut self,
31049         sampler_ycbcr_conversion_components: ComponentMapping,
31050     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31051         self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
31052         self
31053     }
suggested_ycbcr_model( mut self, suggested_ycbcr_model: SamplerYcbcrModelConversion, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31054     pub fn suggested_ycbcr_model(
31055         mut self,
31056         suggested_ycbcr_model: SamplerYcbcrModelConversion,
31057     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31058         self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
31059         self
31060     }
suggested_ycbcr_range( mut self, suggested_ycbcr_range: SamplerYcbcrRange, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31061     pub fn suggested_ycbcr_range(
31062         mut self,
31063         suggested_ycbcr_range: SamplerYcbcrRange,
31064     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31065         self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
31066         self
31067     }
suggested_x_chroma_offset( mut self, suggested_x_chroma_offset: ChromaLocation, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31068     pub fn suggested_x_chroma_offset(
31069         mut self,
31070         suggested_x_chroma_offset: ChromaLocation,
31071     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31072         self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
31073         self
31074     }
suggested_y_chroma_offset( mut self, suggested_y_chroma_offset: ChromaLocation, ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a>31075     pub fn suggested_y_chroma_offset(
31076         mut self,
31077         suggested_y_chroma_offset: ChromaLocation,
31078     ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
31079         self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
31080         self
31081     }
31082     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31083     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31084     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AndroidHardwareBufferFormatPropertiesANDROID31085     pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID {
31086         self.inner
31087     }
31088 }
31089 #[repr(C)]
31090 #[derive(Copy, Clone, Debug)]
31091 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>"]
31092 pub struct CommandBufferInheritanceConditionalRenderingInfoEXT {
31093     pub s_type: StructureType,
31094     pub p_next: *const c_void,
31095     pub conditional_rendering_enable: Bool32,
31096 }
31097 impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT {
default() -> CommandBufferInheritanceConditionalRenderingInfoEXT31098     fn default() -> CommandBufferInheritanceConditionalRenderingInfoEXT {
31099         CommandBufferInheritanceConditionalRenderingInfoEXT {
31100             s_type: StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
31101             p_next: ::std::ptr::null(),
31102             conditional_rendering_enable: Bool32::default(),
31103         }
31104     }
31105 }
31106 impl CommandBufferInheritanceConditionalRenderingInfoEXT {
builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a>31107     pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
31108         CommandBufferInheritanceConditionalRenderingInfoEXTBuilder {
31109             inner: CommandBufferInheritanceConditionalRenderingInfoEXT::default(),
31110             marker: ::std::marker::PhantomData,
31111         }
31112     }
31113 }
31114 #[repr(transparent)]
31115 pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
31116     inner: CommandBufferInheritanceConditionalRenderingInfoEXT,
31117     marker: ::std::marker::PhantomData<&'a ()>,
31118 }
31119 unsafe impl ExtendsCommandBufferInheritanceInfo
31120     for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_>
31121 {
31122 }
31123 unsafe impl ExtendsCommandBufferInheritanceInfo
31124     for CommandBufferInheritanceConditionalRenderingInfoEXT
31125 {
31126 }
31127 impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
31128     type Target = CommandBufferInheritanceConditionalRenderingInfoEXT;
deref(&self) -> &Self::Target31129     fn deref(&self) -> &Self::Target {
31130         &self.inner
31131     }
31132 }
31133 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31134     fn deref_mut(&mut self) -> &mut Self::Target {
31135         &mut self.inner
31136     }
31137 }
31138 impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
conditional_rendering_enable( mut self, conditional_rendering_enable: bool, ) -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a>31139     pub fn conditional_rendering_enable(
31140         mut self,
31141         conditional_rendering_enable: bool,
31142     ) -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
31143         self.inner.conditional_rendering_enable = conditional_rendering_enable.into();
31144         self
31145     }
31146     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31147     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31148     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT31149     pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT {
31150         self.inner
31151     }
31152 }
31153 #[repr(C)]
31154 #[derive(Copy, Clone, Debug)]
31155 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFormatANDROID.html>"]
31156 pub struct ExternalFormatANDROID {
31157     pub s_type: StructureType,
31158     pub p_next: *mut c_void,
31159     pub external_format: u64,
31160 }
31161 impl ::std::default::Default for ExternalFormatANDROID {
default() -> ExternalFormatANDROID31162     fn default() -> ExternalFormatANDROID {
31163         ExternalFormatANDROID {
31164             s_type: StructureType::EXTERNAL_FORMAT_ANDROID,
31165             p_next: ::std::ptr::null_mut(),
31166             external_format: u64::default(),
31167         }
31168     }
31169 }
31170 impl ExternalFormatANDROID {
builder<'a>() -> ExternalFormatANDROIDBuilder<'a>31171     pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> {
31172         ExternalFormatANDROIDBuilder {
31173             inner: ExternalFormatANDROID::default(),
31174             marker: ::std::marker::PhantomData,
31175         }
31176     }
31177 }
31178 #[repr(transparent)]
31179 pub struct ExternalFormatANDROIDBuilder<'a> {
31180     inner: ExternalFormatANDROID,
31181     marker: ::std::marker::PhantomData<&'a ()>,
31182 }
31183 unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
31184 unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {}
31185 unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
31186 unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {}
31187 impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> {
31188     type Target = ExternalFormatANDROID;
deref(&self) -> &Self::Target31189     fn deref(&self) -> &Self::Target {
31190         &self.inner
31191     }
31192 }
31193 impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31194     fn deref_mut(&mut self) -> &mut Self::Target {
31195         &mut self.inner
31196     }
31197 }
31198 impl<'a> ExternalFormatANDROIDBuilder<'a> {
external_format(mut self, external_format: u64) -> ExternalFormatANDROIDBuilder<'a>31199     pub fn external_format(mut self, external_format: u64) -> ExternalFormatANDROIDBuilder<'a> {
31200         self.inner.external_format = external_format;
31201         self
31202     }
31203     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31204     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31205     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ExternalFormatANDROID31206     pub fn build(self) -> ExternalFormatANDROID {
31207         self.inner
31208     }
31209 }
31210 #[repr(C)]
31211 #[derive(Copy, Clone, Debug)]
31212 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html>"]
31213 pub struct PhysicalDevice8BitStorageFeatures {
31214     pub s_type: StructureType,
31215     pub p_next: *mut c_void,
31216     pub storage_buffer8_bit_access: Bool32,
31217     pub uniform_and_storage_buffer8_bit_access: Bool32,
31218     pub storage_push_constant8: Bool32,
31219 }
31220 impl ::std::default::Default for PhysicalDevice8BitStorageFeatures {
default() -> PhysicalDevice8BitStorageFeatures31221     fn default() -> PhysicalDevice8BitStorageFeatures {
31222         PhysicalDevice8BitStorageFeatures {
31223             s_type: StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
31224             p_next: ::std::ptr::null_mut(),
31225             storage_buffer8_bit_access: Bool32::default(),
31226             uniform_and_storage_buffer8_bit_access: Bool32::default(),
31227             storage_push_constant8: Bool32::default(),
31228         }
31229     }
31230 }
31231 impl PhysicalDevice8BitStorageFeatures {
builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a>31232     pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
31233         PhysicalDevice8BitStorageFeaturesBuilder {
31234             inner: PhysicalDevice8BitStorageFeatures::default(),
31235             marker: ::std::marker::PhantomData,
31236         }
31237     }
31238 }
31239 #[repr(transparent)]
31240 pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> {
31241     inner: PhysicalDevice8BitStorageFeatures,
31242     marker: ::std::marker::PhantomData<&'a ()>,
31243 }
31244 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
31245 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {}
31246 impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
31247     type Target = PhysicalDevice8BitStorageFeatures;
deref(&self) -> &Self::Target31248     fn deref(&self) -> &Self::Target {
31249         &self.inner
31250     }
31251 }
31252 impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31253     fn deref_mut(&mut self) -> &mut Self::Target {
31254         &mut self.inner
31255     }
31256 }
31257 impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
storage_buffer8_bit_access( mut self, storage_buffer8_bit_access: bool, ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a>31258     pub fn storage_buffer8_bit_access(
31259         mut self,
31260         storage_buffer8_bit_access: bool,
31261     ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
31262         self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
31263         self
31264     }
uniform_and_storage_buffer8_bit_access( mut self, uniform_and_storage_buffer8_bit_access: bool, ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a>31265     pub fn uniform_and_storage_buffer8_bit_access(
31266         mut self,
31267         uniform_and_storage_buffer8_bit_access: bool,
31268     ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
31269         self.inner.uniform_and_storage_buffer8_bit_access =
31270             uniform_and_storage_buffer8_bit_access.into();
31271         self
31272     }
storage_push_constant8( mut self, storage_push_constant8: bool, ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a>31273     pub fn storage_push_constant8(
31274         mut self,
31275         storage_push_constant8: bool,
31276     ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
31277         self.inner.storage_push_constant8 = storage_push_constant8.into();
31278         self
31279     }
31280     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31281     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31282     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevice8BitStorageFeatures31283     pub fn build(self) -> PhysicalDevice8BitStorageFeatures {
31284         self.inner
31285     }
31286 }
31287 #[repr(C)]
31288 #[derive(Copy, Clone, Debug)]
31289 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>"]
31290 pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
31291     pub s_type: StructureType,
31292     pub p_next: *mut c_void,
31293     pub conditional_rendering: Bool32,
31294     pub inherited_conditional_rendering: Bool32,
31295 }
31296 impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT {
default() -> PhysicalDeviceConditionalRenderingFeaturesEXT31297     fn default() -> PhysicalDeviceConditionalRenderingFeaturesEXT {
31298         PhysicalDeviceConditionalRenderingFeaturesEXT {
31299             s_type: StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
31300             p_next: ::std::ptr::null_mut(),
31301             conditional_rendering: Bool32::default(),
31302             inherited_conditional_rendering: Bool32::default(),
31303         }
31304     }
31305 }
31306 impl PhysicalDeviceConditionalRenderingFeaturesEXT {
builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a>31307     pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
31308         PhysicalDeviceConditionalRenderingFeaturesEXTBuilder {
31309             inner: PhysicalDeviceConditionalRenderingFeaturesEXT::default(),
31310             marker: ::std::marker::PhantomData,
31311         }
31312     }
31313 }
31314 #[repr(transparent)]
31315 pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
31316     inner: PhysicalDeviceConditionalRenderingFeaturesEXT,
31317     marker: ::std::marker::PhantomData<&'a ()>,
31318 }
31319 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {}
31320 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {}
31321 impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
31322     type Target = PhysicalDeviceConditionalRenderingFeaturesEXT;
deref(&self) -> &Self::Target31323     fn deref(&self) -> &Self::Target {
31324         &self.inner
31325     }
31326 }
31327 impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31328     fn deref_mut(&mut self) -> &mut Self::Target {
31329         &mut self.inner
31330     }
31331 }
31332 impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
conditional_rendering( mut self, conditional_rendering: bool, ) -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a>31333     pub fn conditional_rendering(
31334         mut self,
31335         conditional_rendering: bool,
31336     ) -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
31337         self.inner.conditional_rendering = conditional_rendering.into();
31338         self
31339     }
inherited_conditional_rendering( mut self, inherited_conditional_rendering: bool, ) -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a>31340     pub fn inherited_conditional_rendering(
31341         mut self,
31342         inherited_conditional_rendering: bool,
31343     ) -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
31344         self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into();
31345         self
31346     }
31347     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31348     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31349     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT31350     pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT {
31351         self.inner
31352     }
31353 }
31354 #[repr(C)]
31355 #[derive(Copy, Clone, Debug)]
31356 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>"]
31357 pub struct PhysicalDeviceVulkanMemoryModelFeatures {
31358     pub s_type: StructureType,
31359     pub p_next: *mut c_void,
31360     pub vulkan_memory_model: Bool32,
31361     pub vulkan_memory_model_device_scope: Bool32,
31362     pub vulkan_memory_model_availability_visibility_chains: Bool32,
31363 }
31364 impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures {
default() -> PhysicalDeviceVulkanMemoryModelFeatures31365     fn default() -> PhysicalDeviceVulkanMemoryModelFeatures {
31366         PhysicalDeviceVulkanMemoryModelFeatures {
31367             s_type: StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
31368             p_next: ::std::ptr::null_mut(),
31369             vulkan_memory_model: Bool32::default(),
31370             vulkan_memory_model_device_scope: Bool32::default(),
31371             vulkan_memory_model_availability_visibility_chains: Bool32::default(),
31372         }
31373     }
31374 }
31375 impl PhysicalDeviceVulkanMemoryModelFeatures {
builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a>31376     pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
31377         PhysicalDeviceVulkanMemoryModelFeaturesBuilder {
31378             inner: PhysicalDeviceVulkanMemoryModelFeatures::default(),
31379             marker: ::std::marker::PhantomData,
31380         }
31381     }
31382 }
31383 #[repr(transparent)]
31384 pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
31385     inner: PhysicalDeviceVulkanMemoryModelFeatures,
31386     marker: ::std::marker::PhantomData<&'a ()>,
31387 }
31388 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
31389 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {}
31390 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
31391     type Target = PhysicalDeviceVulkanMemoryModelFeatures;
deref(&self) -> &Self::Target31392     fn deref(&self) -> &Self::Target {
31393         &self.inner
31394     }
31395 }
31396 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31397     fn deref_mut(&mut self) -> &mut Self::Target {
31398         &mut self.inner
31399     }
31400 }
31401 impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
vulkan_memory_model( mut self, vulkan_memory_model: bool, ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a>31402     pub fn vulkan_memory_model(
31403         mut self,
31404         vulkan_memory_model: bool,
31405     ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
31406         self.inner.vulkan_memory_model = vulkan_memory_model.into();
31407         self
31408     }
vulkan_memory_model_device_scope( mut self, vulkan_memory_model_device_scope: bool, ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a>31409     pub fn vulkan_memory_model_device_scope(
31410         mut self,
31411         vulkan_memory_model_device_scope: bool,
31412     ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
31413         self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
31414         self
31415     }
vulkan_memory_model_availability_visibility_chains( mut self, vulkan_memory_model_availability_visibility_chains: bool, ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a>31416     pub fn vulkan_memory_model_availability_visibility_chains(
31417         mut self,
31418         vulkan_memory_model_availability_visibility_chains: bool,
31419     ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
31420         self.inner
31421             .vulkan_memory_model_availability_visibility_chains =
31422             vulkan_memory_model_availability_visibility_chains.into();
31423         self
31424     }
31425     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31426     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31427     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkanMemoryModelFeatures31428     pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures {
31429         self.inner
31430     }
31431 }
31432 #[repr(C)]
31433 #[derive(Copy, Clone, Debug)]
31434 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>"]
31435 pub struct PhysicalDeviceShaderAtomicInt64Features {
31436     pub s_type: StructureType,
31437     pub p_next: *mut c_void,
31438     pub shader_buffer_int64_atomics: Bool32,
31439     pub shader_shared_int64_atomics: Bool32,
31440 }
31441 impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features {
default() -> PhysicalDeviceShaderAtomicInt64Features31442     fn default() -> PhysicalDeviceShaderAtomicInt64Features {
31443         PhysicalDeviceShaderAtomicInt64Features {
31444             s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
31445             p_next: ::std::ptr::null_mut(),
31446             shader_buffer_int64_atomics: Bool32::default(),
31447             shader_shared_int64_atomics: Bool32::default(),
31448         }
31449     }
31450 }
31451 impl PhysicalDeviceShaderAtomicInt64Features {
builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a>31452     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
31453         PhysicalDeviceShaderAtomicInt64FeaturesBuilder {
31454             inner: PhysicalDeviceShaderAtomicInt64Features::default(),
31455             marker: ::std::marker::PhantomData,
31456         }
31457     }
31458 }
31459 #[repr(transparent)]
31460 pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
31461     inner: PhysicalDeviceShaderAtomicInt64Features,
31462     marker: ::std::marker::PhantomData<&'a ()>,
31463 }
31464 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
31465 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {}
31466 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
31467     type Target = PhysicalDeviceShaderAtomicInt64Features;
deref(&self) -> &Self::Target31468     fn deref(&self) -> &Self::Target {
31469         &self.inner
31470     }
31471 }
31472 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31473     fn deref_mut(&mut self) -> &mut Self::Target {
31474         &mut self.inner
31475     }
31476 }
31477 impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
shader_buffer_int64_atomics( mut self, shader_buffer_int64_atomics: bool, ) -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a>31478     pub fn shader_buffer_int64_atomics(
31479         mut self,
31480         shader_buffer_int64_atomics: bool,
31481     ) -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
31482         self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
31483         self
31484     }
shader_shared_int64_atomics( mut self, shader_shared_int64_atomics: bool, ) -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a>31485     pub fn shader_shared_int64_atomics(
31486         mut self,
31487         shader_shared_int64_atomics: bool,
31488     ) -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
31489         self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
31490         self
31491     }
31492     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31493     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31494     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderAtomicInt64Features31495     pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features {
31496         self.inner
31497     }
31498 }
31499 #[repr(C)]
31500 #[derive(Copy, Clone, Debug)]
31501 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html>"]
31502 pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
31503     pub s_type: StructureType,
31504     pub p_next: *mut c_void,
31505     pub shader_buffer_float32_atomics: Bool32,
31506     pub shader_buffer_float32_atomic_add: Bool32,
31507     pub shader_buffer_float64_atomics: Bool32,
31508     pub shader_buffer_float64_atomic_add: Bool32,
31509     pub shader_shared_float32_atomics: Bool32,
31510     pub shader_shared_float32_atomic_add: Bool32,
31511     pub shader_shared_float64_atomics: Bool32,
31512     pub shader_shared_float64_atomic_add: Bool32,
31513     pub shader_image_float32_atomics: Bool32,
31514     pub shader_image_float32_atomic_add: Bool32,
31515     pub sparse_image_float32_atomics: Bool32,
31516     pub sparse_image_float32_atomic_add: Bool32,
31517 }
31518 impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
default() -> PhysicalDeviceShaderAtomicFloatFeaturesEXT31519     fn default() -> PhysicalDeviceShaderAtomicFloatFeaturesEXT {
31520         PhysicalDeviceShaderAtomicFloatFeaturesEXT {
31521             s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
31522             p_next: ::std::ptr::null_mut(),
31523             shader_buffer_float32_atomics: Bool32::default(),
31524             shader_buffer_float32_atomic_add: Bool32::default(),
31525             shader_buffer_float64_atomics: Bool32::default(),
31526             shader_buffer_float64_atomic_add: Bool32::default(),
31527             shader_shared_float32_atomics: Bool32::default(),
31528             shader_shared_float32_atomic_add: Bool32::default(),
31529             shader_shared_float64_atomics: Bool32::default(),
31530             shader_shared_float64_atomic_add: Bool32::default(),
31531             shader_image_float32_atomics: Bool32::default(),
31532             shader_image_float32_atomic_add: Bool32::default(),
31533             sparse_image_float32_atomics: Bool32::default(),
31534             sparse_image_float32_atomic_add: Bool32::default(),
31535         }
31536     }
31537 }
31538 impl PhysicalDeviceShaderAtomicFloatFeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31539     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31540         PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder {
31541             inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT::default(),
31542             marker: ::std::marker::PhantomData,
31543         }
31544     }
31545 }
31546 #[repr(transparent)]
31547 pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31548     inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT,
31549     marker: ::std::marker::PhantomData<&'a ()>,
31550 }
31551 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {}
31552 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {}
31553 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31554     type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
deref(&self) -> &Self::Target31555     fn deref(&self) -> &Self::Target {
31556         &self.inner
31557     }
31558 }
31559 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31560     fn deref_mut(&mut self) -> &mut Self::Target {
31561         &mut self.inner
31562     }
31563 }
31564 impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
shader_buffer_float32_atomics( mut self, shader_buffer_float32_atomics: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31565     pub fn shader_buffer_float32_atomics(
31566         mut self,
31567         shader_buffer_float32_atomics: bool,
31568     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31569         self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into();
31570         self
31571     }
shader_buffer_float32_atomic_add( mut self, shader_buffer_float32_atomic_add: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31572     pub fn shader_buffer_float32_atomic_add(
31573         mut self,
31574         shader_buffer_float32_atomic_add: bool,
31575     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31576         self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into();
31577         self
31578     }
shader_buffer_float64_atomics( mut self, shader_buffer_float64_atomics: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31579     pub fn shader_buffer_float64_atomics(
31580         mut self,
31581         shader_buffer_float64_atomics: bool,
31582     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31583         self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into();
31584         self
31585     }
shader_buffer_float64_atomic_add( mut self, shader_buffer_float64_atomic_add: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31586     pub fn shader_buffer_float64_atomic_add(
31587         mut self,
31588         shader_buffer_float64_atomic_add: bool,
31589     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31590         self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into();
31591         self
31592     }
shader_shared_float32_atomics( mut self, shader_shared_float32_atomics: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31593     pub fn shader_shared_float32_atomics(
31594         mut self,
31595         shader_shared_float32_atomics: bool,
31596     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31597         self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into();
31598         self
31599     }
shader_shared_float32_atomic_add( mut self, shader_shared_float32_atomic_add: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31600     pub fn shader_shared_float32_atomic_add(
31601         mut self,
31602         shader_shared_float32_atomic_add: bool,
31603     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31604         self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into();
31605         self
31606     }
shader_shared_float64_atomics( mut self, shader_shared_float64_atomics: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31607     pub fn shader_shared_float64_atomics(
31608         mut self,
31609         shader_shared_float64_atomics: bool,
31610     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31611         self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into();
31612         self
31613     }
shader_shared_float64_atomic_add( mut self, shader_shared_float64_atomic_add: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31614     pub fn shader_shared_float64_atomic_add(
31615         mut self,
31616         shader_shared_float64_atomic_add: bool,
31617     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31618         self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into();
31619         self
31620     }
shader_image_float32_atomics( mut self, shader_image_float32_atomics: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31621     pub fn shader_image_float32_atomics(
31622         mut self,
31623         shader_image_float32_atomics: bool,
31624     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31625         self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into();
31626         self
31627     }
shader_image_float32_atomic_add( mut self, shader_image_float32_atomic_add: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31628     pub fn shader_image_float32_atomic_add(
31629         mut self,
31630         shader_image_float32_atomic_add: bool,
31631     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31632         self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into();
31633         self
31634     }
sparse_image_float32_atomics( mut self, sparse_image_float32_atomics: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31635     pub fn sparse_image_float32_atomics(
31636         mut self,
31637         sparse_image_float32_atomics: bool,
31638     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31639         self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into();
31640         self
31641     }
sparse_image_float32_atomic_add( mut self, sparse_image_float32_atomic_add: bool, ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a>31642     pub fn sparse_image_float32_atomic_add(
31643         mut self,
31644         sparse_image_float32_atomic_add: bool,
31645     ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
31646         self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into();
31647         self
31648     }
31649     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31650     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31651     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT31652     pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT {
31653         self.inner
31654     }
31655 }
31656 #[repr(C)]
31657 #[derive(Copy, Clone, Debug)]
31658 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
31659 pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
31660     pub s_type: StructureType,
31661     pub p_next: *mut c_void,
31662     pub vertex_attribute_instance_rate_divisor: Bool32,
31663     pub vertex_attribute_instance_rate_zero_divisor: Bool32,
31664 }
31665 impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
default() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT31666     fn default() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
31667         PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
31668             s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
31669             p_next: ::std::ptr::null_mut(),
31670             vertex_attribute_instance_rate_divisor: Bool32::default(),
31671             vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
31672         }
31673     }
31674 }
31675 impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a>31676     pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
31677         PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder {
31678             inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT::default(),
31679             marker: ::std::marker::PhantomData,
31680         }
31681     }
31682 }
31683 #[repr(transparent)]
31684 pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
31685     inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT,
31686     marker: ::std::marker::PhantomData<&'a ()>,
31687 }
31688 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {}
31689 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
31690 impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
31691     type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
deref(&self) -> &Self::Target31692     fn deref(&self) -> &Self::Target {
31693         &self.inner
31694     }
31695 }
31696 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31697     fn deref_mut(&mut self) -> &mut Self::Target {
31698         &mut self.inner
31699     }
31700 }
31701 impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
vertex_attribute_instance_rate_divisor( mut self, vertex_attribute_instance_rate_divisor: bool, ) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a>31702     pub fn vertex_attribute_instance_rate_divisor(
31703         mut self,
31704         vertex_attribute_instance_rate_divisor: bool,
31705     ) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
31706         self.inner.vertex_attribute_instance_rate_divisor =
31707             vertex_attribute_instance_rate_divisor.into();
31708         self
31709     }
vertex_attribute_instance_rate_zero_divisor( mut self, vertex_attribute_instance_rate_zero_divisor: bool, ) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a>31710     pub fn vertex_attribute_instance_rate_zero_divisor(
31711         mut self,
31712         vertex_attribute_instance_rate_zero_divisor: bool,
31713     ) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
31714         self.inner.vertex_attribute_instance_rate_zero_divisor =
31715             vertex_attribute_instance_rate_zero_divisor.into();
31716         self
31717     }
31718     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31719     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31720     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT31721     pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
31722         self.inner
31723     }
31724 }
31725 #[repr(C)]
31726 #[derive(Copy, Clone, Debug)]
31727 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html>"]
31728 pub struct QueueFamilyCheckpointPropertiesNV {
31729     pub s_type: StructureType,
31730     pub p_next: *mut c_void,
31731     pub checkpoint_execution_stage_mask: PipelineStageFlags,
31732 }
31733 impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV {
default() -> QueueFamilyCheckpointPropertiesNV31734     fn default() -> QueueFamilyCheckpointPropertiesNV {
31735         QueueFamilyCheckpointPropertiesNV {
31736             s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
31737             p_next: ::std::ptr::null_mut(),
31738             checkpoint_execution_stage_mask: PipelineStageFlags::default(),
31739         }
31740     }
31741 }
31742 impl QueueFamilyCheckpointPropertiesNV {
builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a>31743     pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
31744         QueueFamilyCheckpointPropertiesNVBuilder {
31745             inner: QueueFamilyCheckpointPropertiesNV::default(),
31746             marker: ::std::marker::PhantomData,
31747         }
31748     }
31749 }
31750 #[repr(transparent)]
31751 pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> {
31752     inner: QueueFamilyCheckpointPropertiesNV,
31753     marker: ::std::marker::PhantomData<&'a ()>,
31754 }
31755 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {}
31756 unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {}
31757 impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
31758     type Target = QueueFamilyCheckpointPropertiesNV;
deref(&self) -> &Self::Target31759     fn deref(&self) -> &Self::Target {
31760         &self.inner
31761     }
31762 }
31763 impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31764     fn deref_mut(&mut self) -> &mut Self::Target {
31765         &mut self.inner
31766     }
31767 }
31768 impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
checkpoint_execution_stage_mask( mut self, checkpoint_execution_stage_mask: PipelineStageFlags, ) -> QueueFamilyCheckpointPropertiesNVBuilder<'a>31769     pub fn checkpoint_execution_stage_mask(
31770         mut self,
31771         checkpoint_execution_stage_mask: PipelineStageFlags,
31772     ) -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
31773         self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
31774         self
31775     }
31776     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31777     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31778     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueueFamilyCheckpointPropertiesNV31779     pub fn build(self) -> QueueFamilyCheckpointPropertiesNV {
31780         self.inner
31781     }
31782 }
31783 #[repr(C)]
31784 #[derive(Copy, Clone, Debug)]
31785 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCheckpointDataNV.html>"]
31786 pub struct CheckpointDataNV {
31787     pub s_type: StructureType,
31788     pub p_next: *mut c_void,
31789     pub stage: PipelineStageFlags,
31790     pub p_checkpoint_marker: *mut c_void,
31791 }
31792 impl ::std::default::Default for CheckpointDataNV {
default() -> CheckpointDataNV31793     fn default() -> CheckpointDataNV {
31794         CheckpointDataNV {
31795             s_type: StructureType::CHECKPOINT_DATA_NV,
31796             p_next: ::std::ptr::null_mut(),
31797             stage: PipelineStageFlags::default(),
31798             p_checkpoint_marker: ::std::ptr::null_mut(),
31799         }
31800     }
31801 }
31802 impl CheckpointDataNV {
builder<'a>() -> CheckpointDataNVBuilder<'a>31803     pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> {
31804         CheckpointDataNVBuilder {
31805             inner: CheckpointDataNV::default(),
31806             marker: ::std::marker::PhantomData,
31807         }
31808     }
31809 }
31810 #[repr(transparent)]
31811 pub struct CheckpointDataNVBuilder<'a> {
31812     inner: CheckpointDataNV,
31813     marker: ::std::marker::PhantomData<&'a ()>,
31814 }
31815 pub unsafe trait ExtendsCheckpointDataNV {}
31816 impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> {
31817     type Target = CheckpointDataNV;
deref(&self) -> &Self::Target31818     fn deref(&self) -> &Self::Target {
31819         &self.inner
31820     }
31821 }
31822 impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31823     fn deref_mut(&mut self) -> &mut Self::Target {
31824         &mut self.inner
31825     }
31826 }
31827 impl<'a> CheckpointDataNVBuilder<'a> {
stage(mut self, stage: PipelineStageFlags) -> CheckpointDataNVBuilder<'a>31828     pub fn stage(mut self, stage: PipelineStageFlags) -> CheckpointDataNVBuilder<'a> {
31829         self.inner.stage = stage;
31830         self
31831     }
checkpoint_marker( mut self, checkpoint_marker: *mut c_void, ) -> CheckpointDataNVBuilder<'a>31832     pub fn checkpoint_marker(
31833         mut self,
31834         checkpoint_marker: *mut c_void,
31835     ) -> CheckpointDataNVBuilder<'a> {
31836         self.inner.p_checkpoint_marker = checkpoint_marker;
31837         self
31838     }
31839     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
31840     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
31841     #[doc = r" valid extension structs can be pushed into the chain."]
31842     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
31843     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCheckpointDataNV>( mut self, next: &'a mut T, ) -> CheckpointDataNVBuilder<'a>31844     pub fn push_next<T: ExtendsCheckpointDataNV>(
31845         mut self,
31846         next: &'a mut T,
31847     ) -> CheckpointDataNVBuilder<'a> {
31848         unsafe {
31849             let next_ptr = next as *mut T as *mut BaseOutStructure;
31850             let last_next = ptr_chain_iter(next).last().unwrap();
31851             (*last_next).p_next = self.inner.p_next as _;
31852             self.inner.p_next = next_ptr as _;
31853         }
31854         self
31855     }
31856     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31857     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31858     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CheckpointDataNV31859     pub fn build(self) -> CheckpointDataNV {
31860         self.inner
31861     }
31862 }
31863 #[repr(C)]
31864 #[derive(Copy, Clone, Debug)]
31865 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>"]
31866 pub struct PhysicalDeviceDepthStencilResolveProperties {
31867     pub s_type: StructureType,
31868     pub p_next: *mut c_void,
31869     pub supported_depth_resolve_modes: ResolveModeFlags,
31870     pub supported_stencil_resolve_modes: ResolveModeFlags,
31871     pub independent_resolve_none: Bool32,
31872     pub independent_resolve: Bool32,
31873 }
31874 impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties {
default() -> PhysicalDeviceDepthStencilResolveProperties31875     fn default() -> PhysicalDeviceDepthStencilResolveProperties {
31876         PhysicalDeviceDepthStencilResolveProperties {
31877             s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
31878             p_next: ::std::ptr::null_mut(),
31879             supported_depth_resolve_modes: ResolveModeFlags::default(),
31880             supported_stencil_resolve_modes: ResolveModeFlags::default(),
31881             independent_resolve_none: Bool32::default(),
31882             independent_resolve: Bool32::default(),
31883         }
31884     }
31885 }
31886 impl PhysicalDeviceDepthStencilResolveProperties {
builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a>31887     pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
31888         PhysicalDeviceDepthStencilResolvePropertiesBuilder {
31889             inner: PhysicalDeviceDepthStencilResolveProperties::default(),
31890             marker: ::std::marker::PhantomData,
31891         }
31892     }
31893 }
31894 #[repr(transparent)]
31895 pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
31896     inner: PhysicalDeviceDepthStencilResolveProperties,
31897     marker: ::std::marker::PhantomData<&'a ()>,
31898 }
31899 unsafe impl ExtendsPhysicalDeviceProperties2
31900     for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_>
31901 {
31902 }
31903 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {}
31904 impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
31905     type Target = PhysicalDeviceDepthStencilResolveProperties;
deref(&self) -> &Self::Target31906     fn deref(&self) -> &Self::Target {
31907         &self.inner
31908     }
31909 }
31910 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31911     fn deref_mut(&mut self) -> &mut Self::Target {
31912         &mut self.inner
31913     }
31914 }
31915 impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
supported_depth_resolve_modes( mut self, supported_depth_resolve_modes: ResolveModeFlags, ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a>31916     pub fn supported_depth_resolve_modes(
31917         mut self,
31918         supported_depth_resolve_modes: ResolveModeFlags,
31919     ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
31920         self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
31921         self
31922     }
supported_stencil_resolve_modes( mut self, supported_stencil_resolve_modes: ResolveModeFlags, ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a>31923     pub fn supported_stencil_resolve_modes(
31924         mut self,
31925         supported_stencil_resolve_modes: ResolveModeFlags,
31926     ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
31927         self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
31928         self
31929     }
independent_resolve_none( mut self, independent_resolve_none: bool, ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a>31930     pub fn independent_resolve_none(
31931         mut self,
31932         independent_resolve_none: bool,
31933     ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
31934         self.inner.independent_resolve_none = independent_resolve_none.into();
31935         self
31936     }
independent_resolve( mut self, independent_resolve: bool, ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a>31937     pub fn independent_resolve(
31938         mut self,
31939         independent_resolve: bool,
31940     ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
31941         self.inner.independent_resolve = independent_resolve.into();
31942         self
31943     }
31944     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
31945     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
31946     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDepthStencilResolveProperties31947     pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties {
31948         self.inner
31949     }
31950 }
31951 #[repr(C)]
31952 #[derive(Copy, Clone, Debug)]
31953 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html>"]
31954 pub struct SubpassDescriptionDepthStencilResolve {
31955     pub s_type: StructureType,
31956     pub p_next: *const c_void,
31957     pub depth_resolve_mode: ResolveModeFlags,
31958     pub stencil_resolve_mode: ResolveModeFlags,
31959     pub p_depth_stencil_resolve_attachment: *const AttachmentReference2,
31960 }
31961 impl ::std::default::Default for SubpassDescriptionDepthStencilResolve {
default() -> SubpassDescriptionDepthStencilResolve31962     fn default() -> SubpassDescriptionDepthStencilResolve {
31963         SubpassDescriptionDepthStencilResolve {
31964             s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
31965             p_next: ::std::ptr::null(),
31966             depth_resolve_mode: ResolveModeFlags::default(),
31967             stencil_resolve_mode: ResolveModeFlags::default(),
31968             p_depth_stencil_resolve_attachment: ::std::ptr::null(),
31969         }
31970     }
31971 }
31972 impl SubpassDescriptionDepthStencilResolve {
builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a>31973     pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
31974         SubpassDescriptionDepthStencilResolveBuilder {
31975             inner: SubpassDescriptionDepthStencilResolve::default(),
31976             marker: ::std::marker::PhantomData,
31977         }
31978     }
31979 }
31980 #[repr(transparent)]
31981 pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> {
31982     inner: SubpassDescriptionDepthStencilResolve,
31983     marker: ::std::marker::PhantomData<&'a ()>,
31984 }
31985 unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {}
31986 unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {}
31987 impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> {
31988     type Target = SubpassDescriptionDepthStencilResolve;
deref(&self) -> &Self::Target31989     fn deref(&self) -> &Self::Target {
31990         &self.inner
31991     }
31992 }
31993 impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target31994     fn deref_mut(&mut self) -> &mut Self::Target {
31995         &mut self.inner
31996     }
31997 }
31998 impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
depth_resolve_mode( mut self, depth_resolve_mode: ResolveModeFlags, ) -> SubpassDescriptionDepthStencilResolveBuilder<'a>31999     pub fn depth_resolve_mode(
32000         mut self,
32001         depth_resolve_mode: ResolveModeFlags,
32002     ) -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
32003         self.inner.depth_resolve_mode = depth_resolve_mode;
32004         self
32005     }
stencil_resolve_mode( mut self, stencil_resolve_mode: ResolveModeFlags, ) -> SubpassDescriptionDepthStencilResolveBuilder<'a>32006     pub fn stencil_resolve_mode(
32007         mut self,
32008         stencil_resolve_mode: ResolveModeFlags,
32009     ) -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
32010         self.inner.stencil_resolve_mode = stencil_resolve_mode;
32011         self
32012     }
depth_stencil_resolve_attachment( mut self, depth_stencil_resolve_attachment: &'a AttachmentReference2, ) -> SubpassDescriptionDepthStencilResolveBuilder<'a>32013     pub fn depth_stencil_resolve_attachment(
32014         mut self,
32015         depth_stencil_resolve_attachment: &'a AttachmentReference2,
32016     ) -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
32017         self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment;
32018         self
32019     }
32020     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32021     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32022     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SubpassDescriptionDepthStencilResolve32023     pub fn build(self) -> SubpassDescriptionDepthStencilResolve {
32024         self.inner
32025     }
32026 }
32027 #[repr(C)]
32028 #[derive(Copy, Clone, Debug)]
32029 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewASTCDecodeModeEXT.html>"]
32030 pub struct ImageViewASTCDecodeModeEXT {
32031     pub s_type: StructureType,
32032     pub p_next: *const c_void,
32033     pub decode_mode: Format,
32034 }
32035 impl ::std::default::Default for ImageViewASTCDecodeModeEXT {
default() -> ImageViewASTCDecodeModeEXT32036     fn default() -> ImageViewASTCDecodeModeEXT {
32037         ImageViewASTCDecodeModeEXT {
32038             s_type: StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
32039             p_next: ::std::ptr::null(),
32040             decode_mode: Format::default(),
32041         }
32042     }
32043 }
32044 impl ImageViewASTCDecodeModeEXT {
builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a>32045     pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> {
32046         ImageViewASTCDecodeModeEXTBuilder {
32047             inner: ImageViewASTCDecodeModeEXT::default(),
32048             marker: ::std::marker::PhantomData,
32049         }
32050     }
32051 }
32052 #[repr(transparent)]
32053 pub struct ImageViewASTCDecodeModeEXTBuilder<'a> {
32054     inner: ImageViewASTCDecodeModeEXT,
32055     marker: ::std::marker::PhantomData<&'a ()>,
32056 }
32057 unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {}
32058 unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {}
32059 impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> {
32060     type Target = ImageViewASTCDecodeModeEXT;
deref(&self) -> &Self::Target32061     fn deref(&self) -> &Self::Target {
32062         &self.inner
32063     }
32064 }
32065 impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32066     fn deref_mut(&mut self) -> &mut Self::Target {
32067         &mut self.inner
32068     }
32069 }
32070 impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
decode_mode(mut self, decode_mode: Format) -> ImageViewASTCDecodeModeEXTBuilder<'a>32071     pub fn decode_mode(mut self, decode_mode: Format) -> ImageViewASTCDecodeModeEXTBuilder<'a> {
32072         self.inner.decode_mode = decode_mode;
32073         self
32074     }
32075     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32076     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32077     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewASTCDecodeModeEXT32078     pub fn build(self) -> ImageViewASTCDecodeModeEXT {
32079         self.inner
32080     }
32081 }
32082 #[repr(C)]
32083 #[derive(Copy, Clone, Debug)]
32084 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>"]
32085 pub struct PhysicalDeviceASTCDecodeFeaturesEXT {
32086     pub s_type: StructureType,
32087     pub p_next: *mut c_void,
32088     pub decode_mode_shared_exponent: Bool32,
32089 }
32090 impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT {
default() -> PhysicalDeviceASTCDecodeFeaturesEXT32091     fn default() -> PhysicalDeviceASTCDecodeFeaturesEXT {
32092         PhysicalDeviceASTCDecodeFeaturesEXT {
32093             s_type: StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
32094             p_next: ::std::ptr::null_mut(),
32095             decode_mode_shared_exponent: Bool32::default(),
32096         }
32097     }
32098 }
32099 impl PhysicalDeviceASTCDecodeFeaturesEXT {
builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a>32100     pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
32101         PhysicalDeviceASTCDecodeFeaturesEXTBuilder {
32102             inner: PhysicalDeviceASTCDecodeFeaturesEXT::default(),
32103             marker: ::std::marker::PhantomData,
32104         }
32105     }
32106 }
32107 #[repr(transparent)]
32108 pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
32109     inner: PhysicalDeviceASTCDecodeFeaturesEXT,
32110     marker: ::std::marker::PhantomData<&'a ()>,
32111 }
32112 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
32113 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {}
32114 impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
32115     type Target = PhysicalDeviceASTCDecodeFeaturesEXT;
deref(&self) -> &Self::Target32116     fn deref(&self) -> &Self::Target {
32117         &self.inner
32118     }
32119 }
32120 impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32121     fn deref_mut(&mut self) -> &mut Self::Target {
32122         &mut self.inner
32123     }
32124 }
32125 impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
decode_mode_shared_exponent( mut self, decode_mode_shared_exponent: bool, ) -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a>32126     pub fn decode_mode_shared_exponent(
32127         mut self,
32128         decode_mode_shared_exponent: bool,
32129     ) -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
32130         self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into();
32131         self
32132     }
32133     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32134     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32135     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT32136     pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT {
32137         self.inner
32138     }
32139 }
32140 #[repr(C)]
32141 #[derive(Copy, Clone, Debug)]
32142 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>"]
32143 pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
32144     pub s_type: StructureType,
32145     pub p_next: *mut c_void,
32146     pub transform_feedback: Bool32,
32147     pub geometry_streams: Bool32,
32148 }
32149 impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT {
default() -> PhysicalDeviceTransformFeedbackFeaturesEXT32150     fn default() -> PhysicalDeviceTransformFeedbackFeaturesEXT {
32151         PhysicalDeviceTransformFeedbackFeaturesEXT {
32152             s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
32153             p_next: ::std::ptr::null_mut(),
32154             transform_feedback: Bool32::default(),
32155             geometry_streams: Bool32::default(),
32156         }
32157     }
32158 }
32159 impl PhysicalDeviceTransformFeedbackFeaturesEXT {
builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a>32160     pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
32161         PhysicalDeviceTransformFeedbackFeaturesEXTBuilder {
32162             inner: PhysicalDeviceTransformFeedbackFeaturesEXT::default(),
32163             marker: ::std::marker::PhantomData,
32164         }
32165     }
32166 }
32167 #[repr(transparent)]
32168 pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
32169     inner: PhysicalDeviceTransformFeedbackFeaturesEXT,
32170     marker: ::std::marker::PhantomData<&'a ()>,
32171 }
32172 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {}
32173 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {}
32174 impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
32175     type Target = PhysicalDeviceTransformFeedbackFeaturesEXT;
deref(&self) -> &Self::Target32176     fn deref(&self) -> &Self::Target {
32177         &self.inner
32178     }
32179 }
32180 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32181     fn deref_mut(&mut self) -> &mut Self::Target {
32182         &mut self.inner
32183     }
32184 }
32185 impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
transform_feedback( mut self, transform_feedback: bool, ) -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a>32186     pub fn transform_feedback(
32187         mut self,
32188         transform_feedback: bool,
32189     ) -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
32190         self.inner.transform_feedback = transform_feedback.into();
32191         self
32192     }
geometry_streams( mut self, geometry_streams: bool, ) -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a>32193     pub fn geometry_streams(
32194         mut self,
32195         geometry_streams: bool,
32196     ) -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
32197         self.inner.geometry_streams = geometry_streams.into();
32198         self
32199     }
32200     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32201     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32202     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT32203     pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT {
32204         self.inner
32205     }
32206 }
32207 #[repr(C)]
32208 #[derive(Copy, Clone, Debug)]
32209 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>"]
32210 pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
32211     pub s_type: StructureType,
32212     pub p_next: *mut c_void,
32213     pub max_transform_feedback_streams: u32,
32214     pub max_transform_feedback_buffers: u32,
32215     pub max_transform_feedback_buffer_size: DeviceSize,
32216     pub max_transform_feedback_stream_data_size: u32,
32217     pub max_transform_feedback_buffer_data_size: u32,
32218     pub max_transform_feedback_buffer_data_stride: u32,
32219     pub transform_feedback_queries: Bool32,
32220     pub transform_feedback_streams_lines_triangles: Bool32,
32221     pub transform_feedback_rasterization_stream_select: Bool32,
32222     pub transform_feedback_draw: Bool32,
32223 }
32224 impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
default() -> PhysicalDeviceTransformFeedbackPropertiesEXT32225     fn default() -> PhysicalDeviceTransformFeedbackPropertiesEXT {
32226         PhysicalDeviceTransformFeedbackPropertiesEXT {
32227             s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
32228             p_next: ::std::ptr::null_mut(),
32229             max_transform_feedback_streams: u32::default(),
32230             max_transform_feedback_buffers: u32::default(),
32231             max_transform_feedback_buffer_size: DeviceSize::default(),
32232             max_transform_feedback_stream_data_size: u32::default(),
32233             max_transform_feedback_buffer_data_size: u32::default(),
32234             max_transform_feedback_buffer_data_stride: u32::default(),
32235             transform_feedback_queries: Bool32::default(),
32236             transform_feedback_streams_lines_triangles: Bool32::default(),
32237             transform_feedback_rasterization_stream_select: Bool32::default(),
32238             transform_feedback_draw: Bool32::default(),
32239         }
32240     }
32241 }
32242 impl PhysicalDeviceTransformFeedbackPropertiesEXT {
builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32243     pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32244         PhysicalDeviceTransformFeedbackPropertiesEXTBuilder {
32245             inner: PhysicalDeviceTransformFeedbackPropertiesEXT::default(),
32246             marker: ::std::marker::PhantomData,
32247         }
32248     }
32249 }
32250 #[repr(transparent)]
32251 pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32252     inner: PhysicalDeviceTransformFeedbackPropertiesEXT,
32253     marker: ::std::marker::PhantomData<&'a ()>,
32254 }
32255 unsafe impl ExtendsPhysicalDeviceProperties2
32256     for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_>
32257 {
32258 }
32259 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {}
32260 impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32261     type Target = PhysicalDeviceTransformFeedbackPropertiesEXT;
deref(&self) -> &Self::Target32262     fn deref(&self) -> &Self::Target {
32263         &self.inner
32264     }
32265 }
32266 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32267     fn deref_mut(&mut self) -> &mut Self::Target {
32268         &mut self.inner
32269     }
32270 }
32271 impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
max_transform_feedback_streams( mut self, max_transform_feedback_streams: u32, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32272     pub fn max_transform_feedback_streams(
32273         mut self,
32274         max_transform_feedback_streams: u32,
32275     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32276         self.inner.max_transform_feedback_streams = max_transform_feedback_streams;
32277         self
32278     }
max_transform_feedback_buffers( mut self, max_transform_feedback_buffers: u32, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32279     pub fn max_transform_feedback_buffers(
32280         mut self,
32281         max_transform_feedback_buffers: u32,
32282     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32283         self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers;
32284         self
32285     }
max_transform_feedback_buffer_size( mut self, max_transform_feedback_buffer_size: DeviceSize, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32286     pub fn max_transform_feedback_buffer_size(
32287         mut self,
32288         max_transform_feedback_buffer_size: DeviceSize,
32289     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32290         self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size;
32291         self
32292     }
max_transform_feedback_stream_data_size( mut self, max_transform_feedback_stream_data_size: u32, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32293     pub fn max_transform_feedback_stream_data_size(
32294         mut self,
32295         max_transform_feedback_stream_data_size: u32,
32296     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32297         self.inner.max_transform_feedback_stream_data_size =
32298             max_transform_feedback_stream_data_size;
32299         self
32300     }
max_transform_feedback_buffer_data_size( mut self, max_transform_feedback_buffer_data_size: u32, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32301     pub fn max_transform_feedback_buffer_data_size(
32302         mut self,
32303         max_transform_feedback_buffer_data_size: u32,
32304     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32305         self.inner.max_transform_feedback_buffer_data_size =
32306             max_transform_feedback_buffer_data_size;
32307         self
32308     }
max_transform_feedback_buffer_data_stride( mut self, max_transform_feedback_buffer_data_stride: u32, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32309     pub fn max_transform_feedback_buffer_data_stride(
32310         mut self,
32311         max_transform_feedback_buffer_data_stride: u32,
32312     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32313         self.inner.max_transform_feedback_buffer_data_stride =
32314             max_transform_feedback_buffer_data_stride;
32315         self
32316     }
transform_feedback_queries( mut self, transform_feedback_queries: bool, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32317     pub fn transform_feedback_queries(
32318         mut self,
32319         transform_feedback_queries: bool,
32320     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32321         self.inner.transform_feedback_queries = transform_feedback_queries.into();
32322         self
32323     }
transform_feedback_streams_lines_triangles( mut self, transform_feedback_streams_lines_triangles: bool, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32324     pub fn transform_feedback_streams_lines_triangles(
32325         mut self,
32326         transform_feedback_streams_lines_triangles: bool,
32327     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32328         self.inner.transform_feedback_streams_lines_triangles =
32329             transform_feedback_streams_lines_triangles.into();
32330         self
32331     }
transform_feedback_rasterization_stream_select( mut self, transform_feedback_rasterization_stream_select: bool, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32332     pub fn transform_feedback_rasterization_stream_select(
32333         mut self,
32334         transform_feedback_rasterization_stream_select: bool,
32335     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32336         self.inner.transform_feedback_rasterization_stream_select =
32337             transform_feedback_rasterization_stream_select.into();
32338         self
32339     }
transform_feedback_draw( mut self, transform_feedback_draw: bool, ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a>32340     pub fn transform_feedback_draw(
32341         mut self,
32342         transform_feedback_draw: bool,
32343     ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
32344         self.inner.transform_feedback_draw = transform_feedback_draw.into();
32345         self
32346     }
32347     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32348     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32349     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT32350     pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT {
32351         self.inner
32352     }
32353 }
32354 #[repr(C)]
32355 #[derive(Copy, Clone, Debug)]
32356 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>"]
32357 pub struct PipelineRasterizationStateStreamCreateInfoEXT {
32358     pub s_type: StructureType,
32359     pub p_next: *const c_void,
32360     pub flags: PipelineRasterizationStateStreamCreateFlagsEXT,
32361     pub rasterization_stream: u32,
32362 }
32363 impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT {
default() -> PipelineRasterizationStateStreamCreateInfoEXT32364     fn default() -> PipelineRasterizationStateStreamCreateInfoEXT {
32365         PipelineRasterizationStateStreamCreateInfoEXT {
32366             s_type: StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
32367             p_next: ::std::ptr::null(),
32368             flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(),
32369             rasterization_stream: u32::default(),
32370         }
32371     }
32372 }
32373 impl PipelineRasterizationStateStreamCreateInfoEXT {
builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a>32374     pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
32375         PipelineRasterizationStateStreamCreateInfoEXTBuilder {
32376             inner: PipelineRasterizationStateStreamCreateInfoEXT::default(),
32377             marker: ::std::marker::PhantomData,
32378         }
32379     }
32380 }
32381 #[repr(transparent)]
32382 pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
32383     inner: PipelineRasterizationStateStreamCreateInfoEXT,
32384     marker: ::std::marker::PhantomData<&'a ()>,
32385 }
32386 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
32387     for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_>
32388 {
32389 }
32390 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
32391     for PipelineRasterizationStateStreamCreateInfoEXT
32392 {
32393 }
32394 impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
32395     type Target = PipelineRasterizationStateStreamCreateInfoEXT;
deref(&self) -> &Self::Target32396     fn deref(&self) -> &Self::Target {
32397         &self.inner
32398     }
32399 }
32400 impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32401     fn deref_mut(&mut self) -> &mut Self::Target {
32402         &mut self.inner
32403     }
32404 }
32405 impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
flags( mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT, ) -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a>32406     pub fn flags(
32407         mut self,
32408         flags: PipelineRasterizationStateStreamCreateFlagsEXT,
32409     ) -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
32410         self.inner.flags = flags;
32411         self
32412     }
rasterization_stream( mut self, rasterization_stream: u32, ) -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a>32413     pub fn rasterization_stream(
32414         mut self,
32415         rasterization_stream: u32,
32416     ) -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
32417         self.inner.rasterization_stream = rasterization_stream;
32418         self
32419     }
32420     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32421     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32422     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationStateStreamCreateInfoEXT32423     pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT {
32424         self.inner
32425     }
32426 }
32427 #[repr(C)]
32428 #[derive(Copy, Clone, Debug)]
32429 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>"]
32430 pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
32431     pub s_type: StructureType,
32432     pub p_next: *mut c_void,
32433     pub representative_fragment_test: Bool32,
32434 }
32435 impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
default() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV32436     fn default() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
32437         PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
32438             s_type: StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
32439             p_next: ::std::ptr::null_mut(),
32440             representative_fragment_test: Bool32::default(),
32441         }
32442     }
32443 }
32444 impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a>32445     pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
32446         PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder {
32447             inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV::default(),
32448             marker: ::std::marker::PhantomData,
32449         }
32450     }
32451 }
32452 #[repr(transparent)]
32453 pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
32454     inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
32455     marker: ::std::marker::PhantomData<&'a ()>,
32456 }
32457 unsafe impl ExtendsDeviceCreateInfo
32458     for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
32459 {
32460 }
32461 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
32462 impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
32463     type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
deref(&self) -> &Self::Target32464     fn deref(&self) -> &Self::Target {
32465         &self.inner
32466     }
32467 }
32468 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32469     fn deref_mut(&mut self) -> &mut Self::Target {
32470         &mut self.inner
32471     }
32472 }
32473 impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
representative_fragment_test( mut self, representative_fragment_test: bool, ) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a>32474     pub fn representative_fragment_test(
32475         mut self,
32476         representative_fragment_test: bool,
32477     ) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
32478         self.inner.representative_fragment_test = representative_fragment_test.into();
32479         self
32480     }
32481     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32482     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32483     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV32484     pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
32485         self.inner
32486     }
32487 }
32488 #[repr(C)]
32489 #[derive(Copy, Clone, Debug)]
32490 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>"]
32491 pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
32492     pub s_type: StructureType,
32493     pub p_next: *const c_void,
32494     pub representative_fragment_test_enable: Bool32,
32495 }
32496 impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV {
default() -> PipelineRepresentativeFragmentTestStateCreateInfoNV32497     fn default() -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
32498         PipelineRepresentativeFragmentTestStateCreateInfoNV {
32499             s_type: StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
32500             p_next: ::std::ptr::null(),
32501             representative_fragment_test_enable: Bool32::default(),
32502         }
32503     }
32504 }
32505 impl PipelineRepresentativeFragmentTestStateCreateInfoNV {
builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a>32506     pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
32507         PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder {
32508             inner: PipelineRepresentativeFragmentTestStateCreateInfoNV::default(),
32509             marker: ::std::marker::PhantomData,
32510         }
32511     }
32512 }
32513 #[repr(transparent)]
32514 pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
32515     inner: PipelineRepresentativeFragmentTestStateCreateInfoNV,
32516     marker: ::std::marker::PhantomData<&'a ()>,
32517 }
32518 unsafe impl ExtendsGraphicsPipelineCreateInfo
32519     for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_>
32520 {
32521 }
32522 unsafe impl ExtendsGraphicsPipelineCreateInfo
32523     for PipelineRepresentativeFragmentTestStateCreateInfoNV
32524 {
32525 }
32526 impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
32527     type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV;
deref(&self) -> &Self::Target32528     fn deref(&self) -> &Self::Target {
32529         &self.inner
32530     }
32531 }
32532 impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32533     fn deref_mut(&mut self) -> &mut Self::Target {
32534         &mut self.inner
32535     }
32536 }
32537 impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
representative_fragment_test_enable( mut self, representative_fragment_test_enable: bool, ) -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a>32538     pub fn representative_fragment_test_enable(
32539         mut self,
32540         representative_fragment_test_enable: bool,
32541     ) -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
32542         self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into();
32543         self
32544     }
32545     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32546     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32547     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV32548     pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
32549         self.inner
32550     }
32551 }
32552 #[repr(C)]
32553 #[derive(Copy, Clone, Debug)]
32554 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>"]
32555 pub struct PhysicalDeviceExclusiveScissorFeaturesNV {
32556     pub s_type: StructureType,
32557     pub p_next: *mut c_void,
32558     pub exclusive_scissor: Bool32,
32559 }
32560 impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV {
default() -> PhysicalDeviceExclusiveScissorFeaturesNV32561     fn default() -> PhysicalDeviceExclusiveScissorFeaturesNV {
32562         PhysicalDeviceExclusiveScissorFeaturesNV {
32563             s_type: StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
32564             p_next: ::std::ptr::null_mut(),
32565             exclusive_scissor: Bool32::default(),
32566         }
32567     }
32568 }
32569 impl PhysicalDeviceExclusiveScissorFeaturesNV {
builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a>32570     pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
32571         PhysicalDeviceExclusiveScissorFeaturesNVBuilder {
32572             inner: PhysicalDeviceExclusiveScissorFeaturesNV::default(),
32573             marker: ::std::marker::PhantomData,
32574         }
32575     }
32576 }
32577 #[repr(transparent)]
32578 pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
32579     inner: PhysicalDeviceExclusiveScissorFeaturesNV,
32580     marker: ::std::marker::PhantomData<&'a ()>,
32581 }
32582 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
32583 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {}
32584 impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
32585     type Target = PhysicalDeviceExclusiveScissorFeaturesNV;
deref(&self) -> &Self::Target32586     fn deref(&self) -> &Self::Target {
32587         &self.inner
32588     }
32589 }
32590 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32591     fn deref_mut(&mut self) -> &mut Self::Target {
32592         &mut self.inner
32593     }
32594 }
32595 impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
exclusive_scissor( mut self, exclusive_scissor: bool, ) -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a>32596     pub fn exclusive_scissor(
32597         mut self,
32598         exclusive_scissor: bool,
32599     ) -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
32600         self.inner.exclusive_scissor = exclusive_scissor.into();
32601         self
32602     }
32603     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32604     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32605     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV32606     pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV {
32607         self.inner
32608     }
32609 }
32610 #[repr(C)]
32611 #[derive(Copy, Clone, Debug)]
32612 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>"]
32613 pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
32614     pub s_type: StructureType,
32615     pub p_next: *const c_void,
32616     pub exclusive_scissor_count: u32,
32617     pub p_exclusive_scissors: *const Rect2D,
32618 }
32619 impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV {
default() -> PipelineViewportExclusiveScissorStateCreateInfoNV32620     fn default() -> PipelineViewportExclusiveScissorStateCreateInfoNV {
32621         PipelineViewportExclusiveScissorStateCreateInfoNV {
32622             s_type: StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
32623             p_next: ::std::ptr::null(),
32624             exclusive_scissor_count: u32::default(),
32625             p_exclusive_scissors: ::std::ptr::null(),
32626         }
32627     }
32628 }
32629 impl PipelineViewportExclusiveScissorStateCreateInfoNV {
builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a>32630     pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
32631         PipelineViewportExclusiveScissorStateCreateInfoNVBuilder {
32632             inner: PipelineViewportExclusiveScissorStateCreateInfoNV::default(),
32633             marker: ::std::marker::PhantomData,
32634         }
32635     }
32636 }
32637 #[repr(transparent)]
32638 pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
32639     inner: PipelineViewportExclusiveScissorStateCreateInfoNV,
32640     marker: ::std::marker::PhantomData<&'a ()>,
32641 }
32642 unsafe impl ExtendsPipelineViewportStateCreateInfo
32643     for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_>
32644 {
32645 }
32646 unsafe impl ExtendsPipelineViewportStateCreateInfo
32647     for PipelineViewportExclusiveScissorStateCreateInfoNV
32648 {
32649 }
32650 impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
32651     type Target = PipelineViewportExclusiveScissorStateCreateInfoNV;
deref(&self) -> &Self::Target32652     fn deref(&self) -> &Self::Target {
32653         &self.inner
32654     }
32655 }
32656 impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32657     fn deref_mut(&mut self) -> &mut Self::Target {
32658         &mut self.inner
32659     }
32660 }
32661 impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
exclusive_scissors( mut self, exclusive_scissors: &'a [Rect2D], ) -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a>32662     pub fn exclusive_scissors(
32663         mut self,
32664         exclusive_scissors: &'a [Rect2D],
32665     ) -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
32666         self.inner.exclusive_scissor_count = exclusive_scissors.len() as _;
32667         self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr();
32668         self
32669     }
32670     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32671     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32672     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV32673     pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV {
32674         self.inner
32675     }
32676 }
32677 #[repr(C)]
32678 #[derive(Copy, Clone, Debug)]
32679 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>"]
32680 pub struct PhysicalDeviceCornerSampledImageFeaturesNV {
32681     pub s_type: StructureType,
32682     pub p_next: *mut c_void,
32683     pub corner_sampled_image: Bool32,
32684 }
32685 impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV {
default() -> PhysicalDeviceCornerSampledImageFeaturesNV32686     fn default() -> PhysicalDeviceCornerSampledImageFeaturesNV {
32687         PhysicalDeviceCornerSampledImageFeaturesNV {
32688             s_type: StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
32689             p_next: ::std::ptr::null_mut(),
32690             corner_sampled_image: Bool32::default(),
32691         }
32692     }
32693 }
32694 impl PhysicalDeviceCornerSampledImageFeaturesNV {
builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a>32695     pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
32696         PhysicalDeviceCornerSampledImageFeaturesNVBuilder {
32697             inner: PhysicalDeviceCornerSampledImageFeaturesNV::default(),
32698             marker: ::std::marker::PhantomData,
32699         }
32700     }
32701 }
32702 #[repr(transparent)]
32703 pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
32704     inner: PhysicalDeviceCornerSampledImageFeaturesNV,
32705     marker: ::std::marker::PhantomData<&'a ()>,
32706 }
32707 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {}
32708 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {}
32709 impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
32710     type Target = PhysicalDeviceCornerSampledImageFeaturesNV;
deref(&self) -> &Self::Target32711     fn deref(&self) -> &Self::Target {
32712         &self.inner
32713     }
32714 }
32715 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32716     fn deref_mut(&mut self) -> &mut Self::Target {
32717         &mut self.inner
32718     }
32719 }
32720 impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
corner_sampled_image( mut self, corner_sampled_image: bool, ) -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a>32721     pub fn corner_sampled_image(
32722         mut self,
32723         corner_sampled_image: bool,
32724     ) -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
32725         self.inner.corner_sampled_image = corner_sampled_image.into();
32726         self
32727     }
32728     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32729     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32730     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV32731     pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV {
32732         self.inner
32733     }
32734 }
32735 #[repr(C)]
32736 #[derive(Copy, Clone, Debug)]
32737 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>"]
32738 pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV {
32739     pub s_type: StructureType,
32740     pub p_next: *mut c_void,
32741     pub compute_derivative_group_quads: Bool32,
32742     pub compute_derivative_group_linear: Bool32,
32743 }
32744 impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
default() -> PhysicalDeviceComputeShaderDerivativesFeaturesNV32745     fn default() -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
32746         PhysicalDeviceComputeShaderDerivativesFeaturesNV {
32747             s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
32748             p_next: ::std::ptr::null_mut(),
32749             compute_derivative_group_quads: Bool32::default(),
32750             compute_derivative_group_linear: Bool32::default(),
32751         }
32752     }
32753 }
32754 impl PhysicalDeviceComputeShaderDerivativesFeaturesNV {
builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a>32755     pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
32756         PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder {
32757             inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV::default(),
32758             marker: ::std::marker::PhantomData,
32759         }
32760     }
32761 }
32762 #[repr(transparent)]
32763 pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
32764     inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV,
32765     marker: ::std::marker::PhantomData<&'a ()>,
32766 }
32767 unsafe impl ExtendsDeviceCreateInfo
32768     for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
32769 {
32770 }
32771 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
32772 impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
32773     type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
deref(&self) -> &Self::Target32774     fn deref(&self) -> &Self::Target {
32775         &self.inner
32776     }
32777 }
32778 impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32779     fn deref_mut(&mut self) -> &mut Self::Target {
32780         &mut self.inner
32781     }
32782 }
32783 impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
compute_derivative_group_quads( mut self, compute_derivative_group_quads: bool, ) -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a>32784     pub fn compute_derivative_group_quads(
32785         mut self,
32786         compute_derivative_group_quads: bool,
32787     ) -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
32788         self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into();
32789         self
32790     }
compute_derivative_group_linear( mut self, compute_derivative_group_linear: bool, ) -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a>32791     pub fn compute_derivative_group_linear(
32792         mut self,
32793         compute_derivative_group_linear: bool,
32794     ) -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
32795         self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into();
32796         self
32797     }
32798     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32799     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32800     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV32801     pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
32802         self.inner
32803     }
32804 }
32805 #[repr(C)]
32806 #[derive(Copy, Clone, Debug)]
32807 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html>"]
32808 pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
32809     pub s_type: StructureType,
32810     pub p_next: *mut c_void,
32811     pub fragment_shader_barycentric: Bool32,
32812 }
32813 impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
default() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV32814     fn default() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
32815         PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
32816             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
32817             p_next: ::std::ptr::null_mut(),
32818             fragment_shader_barycentric: Bool32::default(),
32819         }
32820     }
32821 }
32822 impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a>32823     pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
32824         PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder {
32825             inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV::default(),
32826             marker: ::std::marker::PhantomData,
32827         }
32828     }
32829 }
32830 #[repr(transparent)]
32831 pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
32832     inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV,
32833     marker: ::std::marker::PhantomData<&'a ()>,
32834 }
32835 unsafe impl ExtendsDeviceCreateInfo
32836     for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
32837 {
32838 }
32839 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
32840 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
32841     type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
deref(&self) -> &Self::Target32842     fn deref(&self) -> &Self::Target {
32843         &self.inner
32844     }
32845 }
32846 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32847     fn deref_mut(&mut self) -> &mut Self::Target {
32848         &mut self.inner
32849     }
32850 }
32851 impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
fragment_shader_barycentric( mut self, fragment_shader_barycentric: bool, ) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a>32852     pub fn fragment_shader_barycentric(
32853         mut self,
32854         fragment_shader_barycentric: bool,
32855     ) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
32856         self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into();
32857         self
32858     }
32859     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32860     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32861     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV32862     pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
32863         self.inner
32864     }
32865 }
32866 #[repr(C)]
32867 #[derive(Copy, Clone, Debug)]
32868 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>"]
32869 pub struct PhysicalDeviceShaderImageFootprintFeaturesNV {
32870     pub s_type: StructureType,
32871     pub p_next: *mut c_void,
32872     pub image_footprint: Bool32,
32873 }
32874 impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV {
default() -> PhysicalDeviceShaderImageFootprintFeaturesNV32875     fn default() -> PhysicalDeviceShaderImageFootprintFeaturesNV {
32876         PhysicalDeviceShaderImageFootprintFeaturesNV {
32877             s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
32878             p_next: ::std::ptr::null_mut(),
32879             image_footprint: Bool32::default(),
32880         }
32881     }
32882 }
32883 impl PhysicalDeviceShaderImageFootprintFeaturesNV {
builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a>32884     pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
32885         PhysicalDeviceShaderImageFootprintFeaturesNVBuilder {
32886             inner: PhysicalDeviceShaderImageFootprintFeaturesNV::default(),
32887             marker: ::std::marker::PhantomData,
32888         }
32889     }
32890 }
32891 #[repr(transparent)]
32892 pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
32893     inner: PhysicalDeviceShaderImageFootprintFeaturesNV,
32894     marker: ::std::marker::PhantomData<&'a ()>,
32895 }
32896 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {}
32897 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {}
32898 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
32899     type Target = PhysicalDeviceShaderImageFootprintFeaturesNV;
deref(&self) -> &Self::Target32900     fn deref(&self) -> &Self::Target {
32901         &self.inner
32902     }
32903 }
32904 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target32905     fn deref_mut(&mut self) -> &mut Self::Target {
32906         &mut self.inner
32907     }
32908 }
32909 impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
image_footprint( mut self, image_footprint: bool, ) -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a>32910     pub fn image_footprint(
32911         mut self,
32912         image_footprint: bool,
32913     ) -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
32914         self.inner.image_footprint = image_footprint.into();
32915         self
32916     }
32917     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32918     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32919     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV32920     pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV {
32921         self.inner
32922     }
32923 }
32924 #[repr(C)]
32925 #[derive(Copy, Clone, Debug)]
32926 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>"]
32927 pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
32928     pub s_type: StructureType,
32929     pub p_next: *mut c_void,
32930     pub dedicated_allocation_image_aliasing: Bool32,
32931 }
32932 impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
default() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32933     fn default() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
32934         PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
32935             s_type: StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
32936             p_next: ::std::ptr::null_mut(),
32937             dedicated_allocation_image_aliasing: Bool32::default(),
32938         }
32939     }
32940 }
32941 impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>32942     pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
32943         PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder {
32944             inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::default(),
32945             marker: ::std::marker::PhantomData,
32946         }
32947     }
32948 }
32949 #[repr(transparent)]
32950 pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
32951     inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
32952     marker: ::std::marker::PhantomData<&'a ()>,
32953 }
32954 unsafe impl ExtendsDeviceCreateInfo
32955     for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
32956 {
32957 }
32958 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {}
32959 impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
32960     type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
deref(&self) -> &Self::Target32961     fn deref(&self) -> &Self::Target {
32962         &self.inner
32963     }
32964 }
32965 impl<'a> ::std::ops::DerefMut
32966     for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>
32967 {
deref_mut(&mut self) -> &mut Self::Target32968     fn deref_mut(&mut self) -> &mut Self::Target {
32969         &mut self.inner
32970     }
32971 }
32972 impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
dedicated_allocation_image_aliasing( mut self, dedicated_allocation_image_aliasing: bool, ) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>32973     pub fn dedicated_allocation_image_aliasing(
32974         mut self,
32975         dedicated_allocation_image_aliasing: bool,
32976     ) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
32977         self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into();
32978         self
32979     }
32980     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
32981     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
32982     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32983     pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
32984         self.inner
32985     }
32986 }
32987 #[repr(C)]
32988 #[derive(Copy, Clone, Debug)]
32989 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShadingRatePaletteNV.html>"]
32990 pub struct ShadingRatePaletteNV {
32991     pub shading_rate_palette_entry_count: u32,
32992     pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
32993 }
32994 impl ::std::default::Default for ShadingRatePaletteNV {
default() -> ShadingRatePaletteNV32995     fn default() -> ShadingRatePaletteNV {
32996         ShadingRatePaletteNV {
32997             shading_rate_palette_entry_count: u32::default(),
32998             p_shading_rate_palette_entries: ::std::ptr::null(),
32999         }
33000     }
33001 }
33002 impl ShadingRatePaletteNV {
builder<'a>() -> ShadingRatePaletteNVBuilder<'a>33003     pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> {
33004         ShadingRatePaletteNVBuilder {
33005             inner: ShadingRatePaletteNV::default(),
33006             marker: ::std::marker::PhantomData,
33007         }
33008     }
33009 }
33010 #[repr(transparent)]
33011 pub struct ShadingRatePaletteNVBuilder<'a> {
33012     inner: ShadingRatePaletteNV,
33013     marker: ::std::marker::PhantomData<&'a ()>,
33014 }
33015 impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> {
33016     type Target = ShadingRatePaletteNV;
deref(&self) -> &Self::Target33017     fn deref(&self) -> &Self::Target {
33018         &self.inner
33019     }
33020 }
33021 impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33022     fn deref_mut(&mut self) -> &mut Self::Target {
33023         &mut self.inner
33024     }
33025 }
33026 impl<'a> ShadingRatePaletteNVBuilder<'a> {
shading_rate_palette_entries( mut self, shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV], ) -> ShadingRatePaletteNVBuilder<'a>33027     pub fn shading_rate_palette_entries(
33028         mut self,
33029         shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV],
33030     ) -> ShadingRatePaletteNVBuilder<'a> {
33031         self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _;
33032         self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr();
33033         self
33034     }
33035     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33036     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33037     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ShadingRatePaletteNV33038     pub fn build(self) -> ShadingRatePaletteNV {
33039         self.inner
33040     }
33041 }
33042 #[repr(C)]
33043 #[derive(Copy, Clone, Debug)]
33044 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>"]
33045 pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
33046     pub s_type: StructureType,
33047     pub p_next: *const c_void,
33048     pub shading_rate_image_enable: Bool32,
33049     pub viewport_count: u32,
33050     pub p_shading_rate_palettes: *const ShadingRatePaletteNV,
33051 }
33052 impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV {
default() -> PipelineViewportShadingRateImageStateCreateInfoNV33053     fn default() -> PipelineViewportShadingRateImageStateCreateInfoNV {
33054         PipelineViewportShadingRateImageStateCreateInfoNV {
33055             s_type: StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
33056             p_next: ::std::ptr::null(),
33057             shading_rate_image_enable: Bool32::default(),
33058             viewport_count: u32::default(),
33059             p_shading_rate_palettes: ::std::ptr::null(),
33060         }
33061     }
33062 }
33063 impl PipelineViewportShadingRateImageStateCreateInfoNV {
builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a>33064     pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
33065         PipelineViewportShadingRateImageStateCreateInfoNVBuilder {
33066             inner: PipelineViewportShadingRateImageStateCreateInfoNV::default(),
33067             marker: ::std::marker::PhantomData,
33068         }
33069     }
33070 }
33071 #[repr(transparent)]
33072 pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
33073     inner: PipelineViewportShadingRateImageStateCreateInfoNV,
33074     marker: ::std::marker::PhantomData<&'a ()>,
33075 }
33076 unsafe impl ExtendsPipelineViewportStateCreateInfo
33077     for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_>
33078 {
33079 }
33080 unsafe impl ExtendsPipelineViewportStateCreateInfo
33081     for PipelineViewportShadingRateImageStateCreateInfoNV
33082 {
33083 }
33084 impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
33085     type Target = PipelineViewportShadingRateImageStateCreateInfoNV;
deref(&self) -> &Self::Target33086     fn deref(&self) -> &Self::Target {
33087         &self.inner
33088     }
33089 }
33090 impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33091     fn deref_mut(&mut self) -> &mut Self::Target {
33092         &mut self.inner
33093     }
33094 }
33095 impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
shading_rate_image_enable( mut self, shading_rate_image_enable: bool, ) -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a>33096     pub fn shading_rate_image_enable(
33097         mut self,
33098         shading_rate_image_enable: bool,
33099     ) -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
33100         self.inner.shading_rate_image_enable = shading_rate_image_enable.into();
33101         self
33102     }
shading_rate_palettes( mut self, shading_rate_palettes: &'a [ShadingRatePaletteNV], ) -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a>33103     pub fn shading_rate_palettes(
33104         mut self,
33105         shading_rate_palettes: &'a [ShadingRatePaletteNV],
33106     ) -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
33107         self.inner.viewport_count = shading_rate_palettes.len() as _;
33108         self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr();
33109         self
33110     }
33111     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33112     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33113     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV33114     pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV {
33115         self.inner
33116     }
33117 }
33118 #[repr(C)]
33119 #[derive(Copy, Clone, Debug)]
33120 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>"]
33121 pub struct PhysicalDeviceShadingRateImageFeaturesNV {
33122     pub s_type: StructureType,
33123     pub p_next: *mut c_void,
33124     pub shading_rate_image: Bool32,
33125     pub shading_rate_coarse_sample_order: Bool32,
33126 }
33127 impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV {
default() -> PhysicalDeviceShadingRateImageFeaturesNV33128     fn default() -> PhysicalDeviceShadingRateImageFeaturesNV {
33129         PhysicalDeviceShadingRateImageFeaturesNV {
33130             s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
33131             p_next: ::std::ptr::null_mut(),
33132             shading_rate_image: Bool32::default(),
33133             shading_rate_coarse_sample_order: Bool32::default(),
33134         }
33135     }
33136 }
33137 impl PhysicalDeviceShadingRateImageFeaturesNV {
builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a>33138     pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
33139         PhysicalDeviceShadingRateImageFeaturesNVBuilder {
33140             inner: PhysicalDeviceShadingRateImageFeaturesNV::default(),
33141             marker: ::std::marker::PhantomData,
33142         }
33143     }
33144 }
33145 #[repr(transparent)]
33146 pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
33147     inner: PhysicalDeviceShadingRateImageFeaturesNV,
33148     marker: ::std::marker::PhantomData<&'a ()>,
33149 }
33150 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
33151 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {}
33152 impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
33153     type Target = PhysicalDeviceShadingRateImageFeaturesNV;
deref(&self) -> &Self::Target33154     fn deref(&self) -> &Self::Target {
33155         &self.inner
33156     }
33157 }
33158 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33159     fn deref_mut(&mut self) -> &mut Self::Target {
33160         &mut self.inner
33161     }
33162 }
33163 impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
shading_rate_image( mut self, shading_rate_image: bool, ) -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a>33164     pub fn shading_rate_image(
33165         mut self,
33166         shading_rate_image: bool,
33167     ) -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
33168         self.inner.shading_rate_image = shading_rate_image.into();
33169         self
33170     }
shading_rate_coarse_sample_order( mut self, shading_rate_coarse_sample_order: bool, ) -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a>33171     pub fn shading_rate_coarse_sample_order(
33172         mut self,
33173         shading_rate_coarse_sample_order: bool,
33174     ) -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
33175         self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into();
33176         self
33177     }
33178     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33179     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33180     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShadingRateImageFeaturesNV33181     pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV {
33182         self.inner
33183     }
33184 }
33185 #[repr(C)]
33186 #[derive(Copy, Clone, Debug)]
33187 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>"]
33188 pub struct PhysicalDeviceShadingRateImagePropertiesNV {
33189     pub s_type: StructureType,
33190     pub p_next: *mut c_void,
33191     pub shading_rate_texel_size: Extent2D,
33192     pub shading_rate_palette_size: u32,
33193     pub shading_rate_max_coarse_samples: u32,
33194 }
33195 impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV {
default() -> PhysicalDeviceShadingRateImagePropertiesNV33196     fn default() -> PhysicalDeviceShadingRateImagePropertiesNV {
33197         PhysicalDeviceShadingRateImagePropertiesNV {
33198             s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
33199             p_next: ::std::ptr::null_mut(),
33200             shading_rate_texel_size: Extent2D::default(),
33201             shading_rate_palette_size: u32::default(),
33202             shading_rate_max_coarse_samples: u32::default(),
33203         }
33204     }
33205 }
33206 impl PhysicalDeviceShadingRateImagePropertiesNV {
builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a>33207     pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
33208         PhysicalDeviceShadingRateImagePropertiesNVBuilder {
33209             inner: PhysicalDeviceShadingRateImagePropertiesNV::default(),
33210             marker: ::std::marker::PhantomData,
33211         }
33212     }
33213 }
33214 #[repr(transparent)]
33215 pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
33216     inner: PhysicalDeviceShadingRateImagePropertiesNV,
33217     marker: ::std::marker::PhantomData<&'a ()>,
33218 }
33219 unsafe impl ExtendsPhysicalDeviceProperties2
33220     for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_>
33221 {
33222 }
33223 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {}
33224 impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
33225     type Target = PhysicalDeviceShadingRateImagePropertiesNV;
deref(&self) -> &Self::Target33226     fn deref(&self) -> &Self::Target {
33227         &self.inner
33228     }
33229 }
33230 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33231     fn deref_mut(&mut self) -> &mut Self::Target {
33232         &mut self.inner
33233     }
33234 }
33235 impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
shading_rate_texel_size( mut self, shading_rate_texel_size: Extent2D, ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a>33236     pub fn shading_rate_texel_size(
33237         mut self,
33238         shading_rate_texel_size: Extent2D,
33239     ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
33240         self.inner.shading_rate_texel_size = shading_rate_texel_size;
33241         self
33242     }
shading_rate_palette_size( mut self, shading_rate_palette_size: u32, ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a>33243     pub fn shading_rate_palette_size(
33244         mut self,
33245         shading_rate_palette_size: u32,
33246     ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
33247         self.inner.shading_rate_palette_size = shading_rate_palette_size;
33248         self
33249     }
shading_rate_max_coarse_samples( mut self, shading_rate_max_coarse_samples: u32, ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a>33250     pub fn shading_rate_max_coarse_samples(
33251         mut self,
33252         shading_rate_max_coarse_samples: u32,
33253     ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
33254         self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples;
33255         self
33256     }
33257     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33258     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33259     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShadingRateImagePropertiesNV33260     pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV {
33261         self.inner
33262     }
33263 }
33264 #[repr(C)]
33265 #[derive(Copy, Clone, Default, Debug)]
33266 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleLocationNV.html>"]
33267 pub struct CoarseSampleLocationNV {
33268     pub pixel_x: u32,
33269     pub pixel_y: u32,
33270     pub sample: u32,
33271 }
33272 impl CoarseSampleLocationNV {
builder<'a>() -> CoarseSampleLocationNVBuilder<'a>33273     pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> {
33274         CoarseSampleLocationNVBuilder {
33275             inner: CoarseSampleLocationNV::default(),
33276             marker: ::std::marker::PhantomData,
33277         }
33278     }
33279 }
33280 #[repr(transparent)]
33281 pub struct CoarseSampleLocationNVBuilder<'a> {
33282     inner: CoarseSampleLocationNV,
33283     marker: ::std::marker::PhantomData<&'a ()>,
33284 }
33285 impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> {
33286     type Target = CoarseSampleLocationNV;
deref(&self) -> &Self::Target33287     fn deref(&self) -> &Self::Target {
33288         &self.inner
33289     }
33290 }
33291 impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33292     fn deref_mut(&mut self) -> &mut Self::Target {
33293         &mut self.inner
33294     }
33295 }
33296 impl<'a> CoarseSampleLocationNVBuilder<'a> {
pixel_x(mut self, pixel_x: u32) -> CoarseSampleLocationNVBuilder<'a>33297     pub fn pixel_x(mut self, pixel_x: u32) -> CoarseSampleLocationNVBuilder<'a> {
33298         self.inner.pixel_x = pixel_x;
33299         self
33300     }
pixel_y(mut self, pixel_y: u32) -> CoarseSampleLocationNVBuilder<'a>33301     pub fn pixel_y(mut self, pixel_y: u32) -> CoarseSampleLocationNVBuilder<'a> {
33302         self.inner.pixel_y = pixel_y;
33303         self
33304     }
sample(mut self, sample: u32) -> CoarseSampleLocationNVBuilder<'a>33305     pub fn sample(mut self, sample: u32) -> CoarseSampleLocationNVBuilder<'a> {
33306         self.inner.sample = sample;
33307         self
33308     }
33309     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33310     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33311     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CoarseSampleLocationNV33312     pub fn build(self) -> CoarseSampleLocationNV {
33313         self.inner
33314     }
33315 }
33316 #[repr(C)]
33317 #[derive(Copy, Clone, Debug)]
33318 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleOrderCustomNV.html>"]
33319 pub struct CoarseSampleOrderCustomNV {
33320     pub shading_rate: ShadingRatePaletteEntryNV,
33321     pub sample_count: u32,
33322     pub sample_location_count: u32,
33323     pub p_sample_locations: *const CoarseSampleLocationNV,
33324 }
33325 impl ::std::default::Default for CoarseSampleOrderCustomNV {
default() -> CoarseSampleOrderCustomNV33326     fn default() -> CoarseSampleOrderCustomNV {
33327         CoarseSampleOrderCustomNV {
33328             shading_rate: ShadingRatePaletteEntryNV::default(),
33329             sample_count: u32::default(),
33330             sample_location_count: u32::default(),
33331             p_sample_locations: ::std::ptr::null(),
33332         }
33333     }
33334 }
33335 impl CoarseSampleOrderCustomNV {
builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a>33336     pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> {
33337         CoarseSampleOrderCustomNVBuilder {
33338             inner: CoarseSampleOrderCustomNV::default(),
33339             marker: ::std::marker::PhantomData,
33340         }
33341     }
33342 }
33343 #[repr(transparent)]
33344 pub struct CoarseSampleOrderCustomNVBuilder<'a> {
33345     inner: CoarseSampleOrderCustomNV,
33346     marker: ::std::marker::PhantomData<&'a ()>,
33347 }
33348 impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> {
33349     type Target = CoarseSampleOrderCustomNV;
deref(&self) -> &Self::Target33350     fn deref(&self) -> &Self::Target {
33351         &self.inner
33352     }
33353 }
33354 impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33355     fn deref_mut(&mut self) -> &mut Self::Target {
33356         &mut self.inner
33357     }
33358 }
33359 impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
shading_rate( mut self, shading_rate: ShadingRatePaletteEntryNV, ) -> CoarseSampleOrderCustomNVBuilder<'a>33360     pub fn shading_rate(
33361         mut self,
33362         shading_rate: ShadingRatePaletteEntryNV,
33363     ) -> CoarseSampleOrderCustomNVBuilder<'a> {
33364         self.inner.shading_rate = shading_rate;
33365         self
33366     }
sample_count(mut self, sample_count: u32) -> CoarseSampleOrderCustomNVBuilder<'a>33367     pub fn sample_count(mut self, sample_count: u32) -> CoarseSampleOrderCustomNVBuilder<'a> {
33368         self.inner.sample_count = sample_count;
33369         self
33370     }
sample_locations( mut self, sample_locations: &'a [CoarseSampleLocationNV], ) -> CoarseSampleOrderCustomNVBuilder<'a>33371     pub fn sample_locations(
33372         mut self,
33373         sample_locations: &'a [CoarseSampleLocationNV],
33374     ) -> CoarseSampleOrderCustomNVBuilder<'a> {
33375         self.inner.sample_location_count = sample_locations.len() as _;
33376         self.inner.p_sample_locations = sample_locations.as_ptr();
33377         self
33378     }
33379     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33380     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33381     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CoarseSampleOrderCustomNV33382     pub fn build(self) -> CoarseSampleOrderCustomNV {
33383         self.inner
33384     }
33385 }
33386 #[repr(C)]
33387 #[derive(Copy, Clone, Debug)]
33388 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>"]
33389 pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
33390     pub s_type: StructureType,
33391     pub p_next: *const c_void,
33392     pub sample_order_type: CoarseSampleOrderTypeNV,
33393     pub custom_sample_order_count: u32,
33394     pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
33395 }
33396 impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
default() -> PipelineViewportCoarseSampleOrderStateCreateInfoNV33397     fn default() -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
33398         PipelineViewportCoarseSampleOrderStateCreateInfoNV {
33399             s_type: StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
33400             p_next: ::std::ptr::null(),
33401             sample_order_type: CoarseSampleOrderTypeNV::default(),
33402             custom_sample_order_count: u32::default(),
33403             p_custom_sample_orders: ::std::ptr::null(),
33404         }
33405     }
33406 }
33407 impl PipelineViewportCoarseSampleOrderStateCreateInfoNV {
builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a>33408     pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
33409         PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder {
33410             inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV::default(),
33411             marker: ::std::marker::PhantomData,
33412         }
33413     }
33414 }
33415 #[repr(transparent)]
33416 pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
33417     inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV,
33418     marker: ::std::marker::PhantomData<&'a ()>,
33419 }
33420 unsafe impl ExtendsPipelineViewportStateCreateInfo
33421     for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_>
33422 {
33423 }
33424 unsafe impl ExtendsPipelineViewportStateCreateInfo
33425     for PipelineViewportCoarseSampleOrderStateCreateInfoNV
33426 {
33427 }
33428 impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
33429     type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
deref(&self) -> &Self::Target33430     fn deref(&self) -> &Self::Target {
33431         &self.inner
33432     }
33433 }
33434 impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33435     fn deref_mut(&mut self) -> &mut Self::Target {
33436         &mut self.inner
33437     }
33438 }
33439 impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
sample_order_type( mut self, sample_order_type: CoarseSampleOrderTypeNV, ) -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a>33440     pub fn sample_order_type(
33441         mut self,
33442         sample_order_type: CoarseSampleOrderTypeNV,
33443     ) -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
33444         self.inner.sample_order_type = sample_order_type;
33445         self
33446     }
custom_sample_orders( mut self, custom_sample_orders: &'a [CoarseSampleOrderCustomNV], ) -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a>33447     pub fn custom_sample_orders(
33448         mut self,
33449         custom_sample_orders: &'a [CoarseSampleOrderCustomNV],
33450     ) -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
33451         self.inner.custom_sample_order_count = custom_sample_orders.len() as _;
33452         self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr();
33453         self
33454     }
33455     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33456     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33457     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV33458     pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
33459         self.inner
33460     }
33461 }
33462 #[repr(C)]
33463 #[derive(Copy, Clone, Debug)]
33464 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>"]
33465 pub struct PhysicalDeviceMeshShaderFeaturesNV {
33466     pub s_type: StructureType,
33467     pub p_next: *mut c_void,
33468     pub task_shader: Bool32,
33469     pub mesh_shader: Bool32,
33470 }
33471 impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV {
default() -> PhysicalDeviceMeshShaderFeaturesNV33472     fn default() -> PhysicalDeviceMeshShaderFeaturesNV {
33473         PhysicalDeviceMeshShaderFeaturesNV {
33474             s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
33475             p_next: ::std::ptr::null_mut(),
33476             task_shader: Bool32::default(),
33477             mesh_shader: Bool32::default(),
33478         }
33479     }
33480 }
33481 impl PhysicalDeviceMeshShaderFeaturesNV {
builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a>33482     pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
33483         PhysicalDeviceMeshShaderFeaturesNVBuilder {
33484             inner: PhysicalDeviceMeshShaderFeaturesNV::default(),
33485             marker: ::std::marker::PhantomData,
33486         }
33487     }
33488 }
33489 #[repr(transparent)]
33490 pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
33491     inner: PhysicalDeviceMeshShaderFeaturesNV,
33492     marker: ::std::marker::PhantomData<&'a ()>,
33493 }
33494 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
33495 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {}
33496 impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
33497     type Target = PhysicalDeviceMeshShaderFeaturesNV;
deref(&self) -> &Self::Target33498     fn deref(&self) -> &Self::Target {
33499         &self.inner
33500     }
33501 }
33502 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33503     fn deref_mut(&mut self) -> &mut Self::Target {
33504         &mut self.inner
33505     }
33506 }
33507 impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
task_shader( mut self, task_shader: bool, ) -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a>33508     pub fn task_shader(
33509         mut self,
33510         task_shader: bool,
33511     ) -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
33512         self.inner.task_shader = task_shader.into();
33513         self
33514     }
mesh_shader( mut self, mesh_shader: bool, ) -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a>33515     pub fn mesh_shader(
33516         mut self,
33517         mesh_shader: bool,
33518     ) -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
33519         self.inner.mesh_shader = mesh_shader.into();
33520         self
33521     }
33522     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33523     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33524     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMeshShaderFeaturesNV33525     pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV {
33526         self.inner
33527     }
33528 }
33529 #[repr(C)]
33530 #[derive(Copy, Clone, Debug)]
33531 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>"]
33532 pub struct PhysicalDeviceMeshShaderPropertiesNV {
33533     pub s_type: StructureType,
33534     pub p_next: *mut c_void,
33535     pub max_draw_mesh_tasks_count: u32,
33536     pub max_task_work_group_invocations: u32,
33537     pub max_task_work_group_size: [u32; 3],
33538     pub max_task_total_memory_size: u32,
33539     pub max_task_output_count: u32,
33540     pub max_mesh_work_group_invocations: u32,
33541     pub max_mesh_work_group_size: [u32; 3],
33542     pub max_mesh_total_memory_size: u32,
33543     pub max_mesh_output_vertices: u32,
33544     pub max_mesh_output_primitives: u32,
33545     pub max_mesh_multiview_view_count: u32,
33546     pub mesh_output_per_vertex_granularity: u32,
33547     pub mesh_output_per_primitive_granularity: u32,
33548 }
33549 impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV {
default() -> PhysicalDeviceMeshShaderPropertiesNV33550     fn default() -> PhysicalDeviceMeshShaderPropertiesNV {
33551         PhysicalDeviceMeshShaderPropertiesNV {
33552             s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
33553             p_next: ::std::ptr::null_mut(),
33554             max_draw_mesh_tasks_count: u32::default(),
33555             max_task_work_group_invocations: u32::default(),
33556             max_task_work_group_size: unsafe { ::std::mem::zeroed() },
33557             max_task_total_memory_size: u32::default(),
33558             max_task_output_count: u32::default(),
33559             max_mesh_work_group_invocations: u32::default(),
33560             max_mesh_work_group_size: unsafe { ::std::mem::zeroed() },
33561             max_mesh_total_memory_size: u32::default(),
33562             max_mesh_output_vertices: u32::default(),
33563             max_mesh_output_primitives: u32::default(),
33564             max_mesh_multiview_view_count: u32::default(),
33565             mesh_output_per_vertex_granularity: u32::default(),
33566             mesh_output_per_primitive_granularity: u32::default(),
33567         }
33568     }
33569 }
33570 impl PhysicalDeviceMeshShaderPropertiesNV {
builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33571     pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33572         PhysicalDeviceMeshShaderPropertiesNVBuilder {
33573             inner: PhysicalDeviceMeshShaderPropertiesNV::default(),
33574             marker: ::std::marker::PhantomData,
33575         }
33576     }
33577 }
33578 #[repr(transparent)]
33579 pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33580     inner: PhysicalDeviceMeshShaderPropertiesNV,
33581     marker: ::std::marker::PhantomData<&'a ()>,
33582 }
33583 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {}
33584 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {}
33585 impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33586     type Target = PhysicalDeviceMeshShaderPropertiesNV;
deref(&self) -> &Self::Target33587     fn deref(&self) -> &Self::Target {
33588         &self.inner
33589     }
33590 }
33591 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33592     fn deref_mut(&mut self) -> &mut Self::Target {
33593         &mut self.inner
33594     }
33595 }
33596 impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
max_draw_mesh_tasks_count( mut self, max_draw_mesh_tasks_count: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33597     pub fn max_draw_mesh_tasks_count(
33598         mut self,
33599         max_draw_mesh_tasks_count: u32,
33600     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33601         self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count;
33602         self
33603     }
max_task_work_group_invocations( mut self, max_task_work_group_invocations: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33604     pub fn max_task_work_group_invocations(
33605         mut self,
33606         max_task_work_group_invocations: u32,
33607     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33608         self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
33609         self
33610     }
max_task_work_group_size( mut self, max_task_work_group_size: [u32; 3], ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33611     pub fn max_task_work_group_size(
33612         mut self,
33613         max_task_work_group_size: [u32; 3],
33614     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33615         self.inner.max_task_work_group_size = max_task_work_group_size;
33616         self
33617     }
max_task_total_memory_size( mut self, max_task_total_memory_size: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33618     pub fn max_task_total_memory_size(
33619         mut self,
33620         max_task_total_memory_size: u32,
33621     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33622         self.inner.max_task_total_memory_size = max_task_total_memory_size;
33623         self
33624     }
max_task_output_count( mut self, max_task_output_count: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33625     pub fn max_task_output_count(
33626         mut self,
33627         max_task_output_count: u32,
33628     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33629         self.inner.max_task_output_count = max_task_output_count;
33630         self
33631     }
max_mesh_work_group_invocations( mut self, max_mesh_work_group_invocations: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33632     pub fn max_mesh_work_group_invocations(
33633         mut self,
33634         max_mesh_work_group_invocations: u32,
33635     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33636         self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
33637         self
33638     }
max_mesh_work_group_size( mut self, max_mesh_work_group_size: [u32; 3], ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33639     pub fn max_mesh_work_group_size(
33640         mut self,
33641         max_mesh_work_group_size: [u32; 3],
33642     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33643         self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
33644         self
33645     }
max_mesh_total_memory_size( mut self, max_mesh_total_memory_size: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33646     pub fn max_mesh_total_memory_size(
33647         mut self,
33648         max_mesh_total_memory_size: u32,
33649     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33650         self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size;
33651         self
33652     }
max_mesh_output_vertices( mut self, max_mesh_output_vertices: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33653     pub fn max_mesh_output_vertices(
33654         mut self,
33655         max_mesh_output_vertices: u32,
33656     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33657         self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
33658         self
33659     }
max_mesh_output_primitives( mut self, max_mesh_output_primitives: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33660     pub fn max_mesh_output_primitives(
33661         mut self,
33662         max_mesh_output_primitives: u32,
33663     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33664         self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
33665         self
33666     }
max_mesh_multiview_view_count( mut self, max_mesh_multiview_view_count: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33667     pub fn max_mesh_multiview_view_count(
33668         mut self,
33669         max_mesh_multiview_view_count: u32,
33670     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33671         self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
33672         self
33673     }
mesh_output_per_vertex_granularity( mut self, mesh_output_per_vertex_granularity: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33674     pub fn mesh_output_per_vertex_granularity(
33675         mut self,
33676         mesh_output_per_vertex_granularity: u32,
33677     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33678         self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
33679         self
33680     }
mesh_output_per_primitive_granularity( mut self, mesh_output_per_primitive_granularity: u32, ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a>33681     pub fn mesh_output_per_primitive_granularity(
33682         mut self,
33683         mesh_output_per_primitive_granularity: u32,
33684     ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
33685         self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity;
33686         self
33687     }
33688     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33689     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33690     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMeshShaderPropertiesNV33691     pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV {
33692         self.inner
33693     }
33694 }
33695 #[repr(C)]
33696 #[derive(Copy, Clone, Default, Debug)]
33697 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html>"]
33698 pub struct DrawMeshTasksIndirectCommandNV {
33699     pub task_count: u32,
33700     pub first_task: u32,
33701 }
33702 impl DrawMeshTasksIndirectCommandNV {
builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a>33703     pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
33704         DrawMeshTasksIndirectCommandNVBuilder {
33705             inner: DrawMeshTasksIndirectCommandNV::default(),
33706             marker: ::std::marker::PhantomData,
33707         }
33708     }
33709 }
33710 #[repr(transparent)]
33711 pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> {
33712     inner: DrawMeshTasksIndirectCommandNV,
33713     marker: ::std::marker::PhantomData<&'a ()>,
33714 }
33715 impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> {
33716     type Target = DrawMeshTasksIndirectCommandNV;
deref(&self) -> &Self::Target33717     fn deref(&self) -> &Self::Target {
33718         &self.inner
33719     }
33720 }
33721 impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33722     fn deref_mut(&mut self) -> &mut Self::Target {
33723         &mut self.inner
33724     }
33725 }
33726 impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> {
task_count(mut self, task_count: u32) -> DrawMeshTasksIndirectCommandNVBuilder<'a>33727     pub fn task_count(mut self, task_count: u32) -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
33728         self.inner.task_count = task_count;
33729         self
33730     }
first_task(mut self, first_task: u32) -> DrawMeshTasksIndirectCommandNVBuilder<'a>33731     pub fn first_task(mut self, first_task: u32) -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
33732         self.inner.first_task = first_task;
33733         self
33734     }
33735     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33736     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33737     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrawMeshTasksIndirectCommandNV33738     pub fn build(self) -> DrawMeshTasksIndirectCommandNV {
33739         self.inner
33740     }
33741 }
33742 #[repr(C)]
33743 #[derive(Copy, Clone, Debug)]
33744 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html>"]
33745 pub struct RayTracingShaderGroupCreateInfoNV {
33746     pub s_type: StructureType,
33747     pub p_next: *const c_void,
33748     pub ty: RayTracingShaderGroupTypeKHR,
33749     pub general_shader: u32,
33750     pub closest_hit_shader: u32,
33751     pub any_hit_shader: u32,
33752     pub intersection_shader: u32,
33753 }
33754 impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV {
default() -> RayTracingShaderGroupCreateInfoNV33755     fn default() -> RayTracingShaderGroupCreateInfoNV {
33756         RayTracingShaderGroupCreateInfoNV {
33757             s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
33758             p_next: ::std::ptr::null(),
33759             ty: RayTracingShaderGroupTypeKHR::default(),
33760             general_shader: u32::default(),
33761             closest_hit_shader: u32::default(),
33762             any_hit_shader: u32::default(),
33763             intersection_shader: u32::default(),
33764         }
33765     }
33766 }
33767 impl RayTracingShaderGroupCreateInfoNV {
builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a>33768     pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33769         RayTracingShaderGroupCreateInfoNVBuilder {
33770             inner: RayTracingShaderGroupCreateInfoNV::default(),
33771             marker: ::std::marker::PhantomData,
33772         }
33773     }
33774 }
33775 #[repr(transparent)]
33776 pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33777     inner: RayTracingShaderGroupCreateInfoNV,
33778     marker: ::std::marker::PhantomData<&'a ()>,
33779 }
33780 pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoNV {}
33781 impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33782     type Target = RayTracingShaderGroupCreateInfoNV;
deref(&self) -> &Self::Target33783     fn deref(&self) -> &Self::Target {
33784         &self.inner
33785     }
33786 }
33787 impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33788     fn deref_mut(&mut self) -> &mut Self::Target {
33789         &mut self.inner
33790     }
33791 }
33792 impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
ty( mut self, ty: RayTracingShaderGroupTypeKHR, ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a>33793     pub fn ty(
33794         mut self,
33795         ty: RayTracingShaderGroupTypeKHR,
33796     ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33797         self.inner.ty = ty;
33798         self
33799     }
general_shader( mut self, general_shader: u32, ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a>33800     pub fn general_shader(
33801         mut self,
33802         general_shader: u32,
33803     ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33804         self.inner.general_shader = general_shader;
33805         self
33806     }
closest_hit_shader( mut self, closest_hit_shader: u32, ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a>33807     pub fn closest_hit_shader(
33808         mut self,
33809         closest_hit_shader: u32,
33810     ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33811         self.inner.closest_hit_shader = closest_hit_shader;
33812         self
33813     }
any_hit_shader( mut self, any_hit_shader: u32, ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a>33814     pub fn any_hit_shader(
33815         mut self,
33816         any_hit_shader: u32,
33817     ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33818         self.inner.any_hit_shader = any_hit_shader;
33819         self
33820     }
intersection_shader( mut self, intersection_shader: u32, ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a>33821     pub fn intersection_shader(
33822         mut self,
33823         intersection_shader: u32,
33824     ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33825         self.inner.intersection_shader = intersection_shader;
33826         self
33827     }
33828     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
33829     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
33830     #[doc = r" valid extension structs can be pushed into the chain."]
33831     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
33832     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRayTracingShaderGroupCreateInfoNV>( mut self, next: &'a mut T, ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a>33833     pub fn push_next<T: ExtendsRayTracingShaderGroupCreateInfoNV>(
33834         mut self,
33835         next: &'a mut T,
33836     ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
33837         unsafe {
33838             let next_ptr = next as *mut T as *mut BaseOutStructure;
33839             let last_next = ptr_chain_iter(next).last().unwrap();
33840             (*last_next).p_next = self.inner.p_next as _;
33841             self.inner.p_next = next_ptr as _;
33842         }
33843         self
33844     }
33845     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33846     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33847     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingShaderGroupCreateInfoNV33848     pub fn build(self) -> RayTracingShaderGroupCreateInfoNV {
33849         self.inner
33850     }
33851 }
33852 #[repr(C)]
33853 #[derive(Copy, Clone, Debug)]
33854 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>"]
33855 pub struct RayTracingShaderGroupCreateInfoKHR {
33856     pub s_type: StructureType,
33857     pub p_next: *const c_void,
33858     pub ty: RayTracingShaderGroupTypeKHR,
33859     pub general_shader: u32,
33860     pub closest_hit_shader: u32,
33861     pub any_hit_shader: u32,
33862     pub intersection_shader: u32,
33863     pub p_shader_group_capture_replay_handle: *const c_void,
33864 }
33865 impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR {
default() -> RayTracingShaderGroupCreateInfoKHR33866     fn default() -> RayTracingShaderGroupCreateInfoKHR {
33867         RayTracingShaderGroupCreateInfoKHR {
33868             s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
33869             p_next: ::std::ptr::null(),
33870             ty: RayTracingShaderGroupTypeKHR::default(),
33871             general_shader: u32::default(),
33872             closest_hit_shader: u32::default(),
33873             any_hit_shader: u32::default(),
33874             intersection_shader: u32::default(),
33875             p_shader_group_capture_replay_handle: ::std::ptr::null(),
33876         }
33877     }
33878 }
33879 impl RayTracingShaderGroupCreateInfoKHR {
builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33880     pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33881         RayTracingShaderGroupCreateInfoKHRBuilder {
33882             inner: RayTracingShaderGroupCreateInfoKHR::default(),
33883             marker: ::std::marker::PhantomData,
33884         }
33885     }
33886 }
33887 #[repr(transparent)]
33888 pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33889     inner: RayTracingShaderGroupCreateInfoKHR,
33890     marker: ::std::marker::PhantomData<&'a ()>,
33891 }
33892 pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoKHR {}
33893 impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33894     type Target = RayTracingShaderGroupCreateInfoKHR;
deref(&self) -> &Self::Target33895     fn deref(&self) -> &Self::Target {
33896         &self.inner
33897     }
33898 }
33899 impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target33900     fn deref_mut(&mut self) -> &mut Self::Target {
33901         &mut self.inner
33902     }
33903 }
33904 impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
ty( mut self, ty: RayTracingShaderGroupTypeKHR, ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33905     pub fn ty(
33906         mut self,
33907         ty: RayTracingShaderGroupTypeKHR,
33908     ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33909         self.inner.ty = ty;
33910         self
33911     }
general_shader( mut self, general_shader: u32, ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33912     pub fn general_shader(
33913         mut self,
33914         general_shader: u32,
33915     ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33916         self.inner.general_shader = general_shader;
33917         self
33918     }
closest_hit_shader( mut self, closest_hit_shader: u32, ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33919     pub fn closest_hit_shader(
33920         mut self,
33921         closest_hit_shader: u32,
33922     ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33923         self.inner.closest_hit_shader = closest_hit_shader;
33924         self
33925     }
any_hit_shader( mut self, any_hit_shader: u32, ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33926     pub fn any_hit_shader(
33927         mut self,
33928         any_hit_shader: u32,
33929     ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33930         self.inner.any_hit_shader = any_hit_shader;
33931         self
33932     }
intersection_shader( mut self, intersection_shader: u32, ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33933     pub fn intersection_shader(
33934         mut self,
33935         intersection_shader: u32,
33936     ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33937         self.inner.intersection_shader = intersection_shader;
33938         self
33939     }
shader_group_capture_replay_handle( mut self, shader_group_capture_replay_handle: *const c_void, ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33940     pub fn shader_group_capture_replay_handle(
33941         mut self,
33942         shader_group_capture_replay_handle: *const c_void,
33943     ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33944         self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle;
33945         self
33946     }
33947     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
33948     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
33949     #[doc = r" valid extension structs can be pushed into the chain."]
33950     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
33951     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRayTracingShaderGroupCreateInfoKHR>( mut self, next: &'a mut T, ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a>33952     pub fn push_next<T: ExtendsRayTracingShaderGroupCreateInfoKHR>(
33953         mut self,
33954         next: &'a mut T,
33955     ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
33956         unsafe {
33957             let next_ptr = next as *mut T as *mut BaseOutStructure;
33958             let last_next = ptr_chain_iter(next).last().unwrap();
33959             (*last_next).p_next = self.inner.p_next as _;
33960             self.inner.p_next = next_ptr as _;
33961         }
33962         self
33963     }
33964     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
33965     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
33966     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingShaderGroupCreateInfoKHR33967     pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR {
33968         self.inner
33969     }
33970 }
33971 #[repr(C)]
33972 #[derive(Copy, Clone, Debug)]
33973 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html>"]
33974 pub struct RayTracingPipelineCreateInfoNV {
33975     pub s_type: StructureType,
33976     pub p_next: *const c_void,
33977     pub flags: PipelineCreateFlags,
33978     pub stage_count: u32,
33979     pub p_stages: *const PipelineShaderStageCreateInfo,
33980     pub group_count: u32,
33981     pub p_groups: *const RayTracingShaderGroupCreateInfoNV,
33982     pub max_recursion_depth: u32,
33983     pub layout: PipelineLayout,
33984     pub base_pipeline_handle: Pipeline,
33985     pub base_pipeline_index: i32,
33986 }
33987 impl ::std::default::Default for RayTracingPipelineCreateInfoNV {
default() -> RayTracingPipelineCreateInfoNV33988     fn default() -> RayTracingPipelineCreateInfoNV {
33989         RayTracingPipelineCreateInfoNV {
33990             s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV,
33991             p_next: ::std::ptr::null(),
33992             flags: PipelineCreateFlags::default(),
33993             stage_count: u32::default(),
33994             p_stages: ::std::ptr::null(),
33995             group_count: u32::default(),
33996             p_groups: ::std::ptr::null(),
33997             max_recursion_depth: u32::default(),
33998             layout: PipelineLayout::default(),
33999             base_pipeline_handle: Pipeline::default(),
34000             base_pipeline_index: i32::default(),
34001         }
34002     }
34003 }
34004 impl RayTracingPipelineCreateInfoNV {
builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a>34005     pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34006         RayTracingPipelineCreateInfoNVBuilder {
34007             inner: RayTracingPipelineCreateInfoNV::default(),
34008             marker: ::std::marker::PhantomData,
34009         }
34010     }
34011 }
34012 #[repr(transparent)]
34013 pub struct RayTracingPipelineCreateInfoNVBuilder<'a> {
34014     inner: RayTracingPipelineCreateInfoNV,
34015     marker: ::std::marker::PhantomData<&'a ()>,
34016 }
34017 pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {}
34018 impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> {
34019     type Target = RayTracingPipelineCreateInfoNV;
deref(&self) -> &Self::Target34020     fn deref(&self) -> &Self::Target {
34021         &self.inner
34022     }
34023 }
34024 impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34025     fn deref_mut(&mut self) -> &mut Self::Target {
34026         &mut self.inner
34027     }
34028 }
34029 impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
flags( mut self, flags: PipelineCreateFlags, ) -> RayTracingPipelineCreateInfoNVBuilder<'a>34030     pub fn flags(
34031         mut self,
34032         flags: PipelineCreateFlags,
34033     ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34034         self.inner.flags = flags;
34035         self
34036     }
stages( mut self, stages: &'a [PipelineShaderStageCreateInfo], ) -> RayTracingPipelineCreateInfoNVBuilder<'a>34037     pub fn stages(
34038         mut self,
34039         stages: &'a [PipelineShaderStageCreateInfo],
34040     ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34041         self.inner.stage_count = stages.len() as _;
34042         self.inner.p_stages = stages.as_ptr();
34043         self
34044     }
groups( mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV], ) -> RayTracingPipelineCreateInfoNVBuilder<'a>34045     pub fn groups(
34046         mut self,
34047         groups: &'a [RayTracingShaderGroupCreateInfoNV],
34048     ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34049         self.inner.group_count = groups.len() as _;
34050         self.inner.p_groups = groups.as_ptr();
34051         self
34052     }
max_recursion_depth( mut self, max_recursion_depth: u32, ) -> RayTracingPipelineCreateInfoNVBuilder<'a>34053     pub fn max_recursion_depth(
34054         mut self,
34055         max_recursion_depth: u32,
34056     ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34057         self.inner.max_recursion_depth = max_recursion_depth;
34058         self
34059     }
layout(mut self, layout: PipelineLayout) -> RayTracingPipelineCreateInfoNVBuilder<'a>34060     pub fn layout(mut self, layout: PipelineLayout) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34061         self.inner.layout = layout;
34062         self
34063     }
base_pipeline_handle( mut self, base_pipeline_handle: Pipeline, ) -> RayTracingPipelineCreateInfoNVBuilder<'a>34064     pub fn base_pipeline_handle(
34065         mut self,
34066         base_pipeline_handle: Pipeline,
34067     ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34068         self.inner.base_pipeline_handle = base_pipeline_handle;
34069         self
34070     }
base_pipeline_index( mut self, base_pipeline_index: i32, ) -> RayTracingPipelineCreateInfoNVBuilder<'a>34071     pub fn base_pipeline_index(
34072         mut self,
34073         base_pipeline_index: i32,
34074     ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34075         self.inner.base_pipeline_index = base_pipeline_index;
34076         self
34077     }
34078     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34079     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34080     #[doc = r" valid extension structs can be pushed into the chain."]
34081     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34082     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRayTracingPipelineCreateInfoNV>( mut self, next: &'a mut T, ) -> RayTracingPipelineCreateInfoNVBuilder<'a>34083     pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(
34084         mut self,
34085         next: &'a mut T,
34086     ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
34087         unsafe {
34088             let next_ptr = next as *mut T as *mut BaseOutStructure;
34089             let last_next = ptr_chain_iter(next).last().unwrap();
34090             (*last_next).p_next = self.inner.p_next as _;
34091             self.inner.p_next = next_ptr as _;
34092         }
34093         self
34094     }
34095     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34096     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34097     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingPipelineCreateInfoNV34098     pub fn build(self) -> RayTracingPipelineCreateInfoNV {
34099         self.inner
34100     }
34101 }
34102 #[repr(C)]
34103 #[derive(Copy, Clone, Debug)]
34104 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html>"]
34105 pub struct RayTracingPipelineCreateInfoKHR {
34106     pub s_type: StructureType,
34107     pub p_next: *const c_void,
34108     pub flags: PipelineCreateFlags,
34109     pub stage_count: u32,
34110     pub p_stages: *const PipelineShaderStageCreateInfo,
34111     pub group_count: u32,
34112     pub p_groups: *const RayTracingShaderGroupCreateInfoKHR,
34113     pub max_pipeline_ray_recursion_depth: u32,
34114     pub p_library_info: *const PipelineLibraryCreateInfoKHR,
34115     pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR,
34116     pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
34117     pub layout: PipelineLayout,
34118     pub base_pipeline_handle: Pipeline,
34119     pub base_pipeline_index: i32,
34120 }
34121 impl ::std::default::Default for RayTracingPipelineCreateInfoKHR {
default() -> RayTracingPipelineCreateInfoKHR34122     fn default() -> RayTracingPipelineCreateInfoKHR {
34123         RayTracingPipelineCreateInfoKHR {
34124             s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
34125             p_next: ::std::ptr::null(),
34126             flags: PipelineCreateFlags::default(),
34127             stage_count: u32::default(),
34128             p_stages: ::std::ptr::null(),
34129             group_count: u32::default(),
34130             p_groups: ::std::ptr::null(),
34131             max_pipeline_ray_recursion_depth: u32::default(),
34132             p_library_info: ::std::ptr::null(),
34133             p_library_interface: ::std::ptr::null(),
34134             p_dynamic_state: ::std::ptr::null(),
34135             layout: PipelineLayout::default(),
34136             base_pipeline_handle: Pipeline::default(),
34137             base_pipeline_index: i32::default(),
34138         }
34139     }
34140 }
34141 impl RayTracingPipelineCreateInfoKHR {
builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a>34142     pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34143         RayTracingPipelineCreateInfoKHRBuilder {
34144             inner: RayTracingPipelineCreateInfoKHR::default(),
34145             marker: ::std::marker::PhantomData,
34146         }
34147     }
34148 }
34149 #[repr(transparent)]
34150 pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> {
34151     inner: RayTracingPipelineCreateInfoKHR,
34152     marker: ::std::marker::PhantomData<&'a ()>,
34153 }
34154 pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {}
34155 impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> {
34156     type Target = RayTracingPipelineCreateInfoKHR;
deref(&self) -> &Self::Target34157     fn deref(&self) -> &Self::Target {
34158         &self.inner
34159     }
34160 }
34161 impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34162     fn deref_mut(&mut self) -> &mut Self::Target {
34163         &mut self.inner
34164     }
34165 }
34166 impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
flags( mut self, flags: PipelineCreateFlags, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34167     pub fn flags(
34168         mut self,
34169         flags: PipelineCreateFlags,
34170     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34171         self.inner.flags = flags;
34172         self
34173     }
stages( mut self, stages: &'a [PipelineShaderStageCreateInfo], ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34174     pub fn stages(
34175         mut self,
34176         stages: &'a [PipelineShaderStageCreateInfo],
34177     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34178         self.inner.stage_count = stages.len() as _;
34179         self.inner.p_stages = stages.as_ptr();
34180         self
34181     }
groups( mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR], ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34182     pub fn groups(
34183         mut self,
34184         groups: &'a [RayTracingShaderGroupCreateInfoKHR],
34185     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34186         self.inner.group_count = groups.len() as _;
34187         self.inner.p_groups = groups.as_ptr();
34188         self
34189     }
max_pipeline_ray_recursion_depth( mut self, max_pipeline_ray_recursion_depth: u32, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34190     pub fn max_pipeline_ray_recursion_depth(
34191         mut self,
34192         max_pipeline_ray_recursion_depth: u32,
34193     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34194         self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth;
34195         self
34196     }
library_info( mut self, library_info: &'a PipelineLibraryCreateInfoKHR, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34197     pub fn library_info(
34198         mut self,
34199         library_info: &'a PipelineLibraryCreateInfoKHR,
34200     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34201         self.inner.p_library_info = library_info;
34202         self
34203     }
library_interface( mut self, library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34204     pub fn library_interface(
34205         mut self,
34206         library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR,
34207     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34208         self.inner.p_library_interface = library_interface;
34209         self
34210     }
dynamic_state( mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34211     pub fn dynamic_state(
34212         mut self,
34213         dynamic_state: &'a PipelineDynamicStateCreateInfo,
34214     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34215         self.inner.p_dynamic_state = dynamic_state;
34216         self
34217     }
layout(mut self, layout: PipelineLayout) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34218     pub fn layout(mut self, layout: PipelineLayout) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34219         self.inner.layout = layout;
34220         self
34221     }
base_pipeline_handle( mut self, base_pipeline_handle: Pipeline, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34222     pub fn base_pipeline_handle(
34223         mut self,
34224         base_pipeline_handle: Pipeline,
34225     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34226         self.inner.base_pipeline_handle = base_pipeline_handle;
34227         self
34228     }
base_pipeline_index( mut self, base_pipeline_index: i32, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34229     pub fn base_pipeline_index(
34230         mut self,
34231         base_pipeline_index: i32,
34232     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34233         self.inner.base_pipeline_index = base_pipeline_index;
34234         self
34235     }
34236     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34237     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34238     #[doc = r" valid extension structs can be pushed into the chain."]
34239     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34240     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>( mut self, next: &'a mut T, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a>34241     pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(
34242         mut self,
34243         next: &'a mut T,
34244     ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
34245         unsafe {
34246             let next_ptr = next as *mut T as *mut BaseOutStructure;
34247             let last_next = ptr_chain_iter(next).last().unwrap();
34248             (*last_next).p_next = self.inner.p_next as _;
34249             self.inner.p_next = next_ptr as _;
34250         }
34251         self
34252     }
34253     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34254     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34255     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingPipelineCreateInfoKHR34256     pub fn build(self) -> RayTracingPipelineCreateInfoKHR {
34257         self.inner
34258     }
34259 }
34260 #[repr(C)]
34261 #[derive(Copy, Clone, Debug)]
34262 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryTrianglesNV.html>"]
34263 pub struct GeometryTrianglesNV {
34264     pub s_type: StructureType,
34265     pub p_next: *const c_void,
34266     pub vertex_data: Buffer,
34267     pub vertex_offset: DeviceSize,
34268     pub vertex_count: u32,
34269     pub vertex_stride: DeviceSize,
34270     pub vertex_format: Format,
34271     pub index_data: Buffer,
34272     pub index_offset: DeviceSize,
34273     pub index_count: u32,
34274     pub index_type: IndexType,
34275     pub transform_data: Buffer,
34276     pub transform_offset: DeviceSize,
34277 }
34278 impl ::std::default::Default for GeometryTrianglesNV {
default() -> GeometryTrianglesNV34279     fn default() -> GeometryTrianglesNV {
34280         GeometryTrianglesNV {
34281             s_type: StructureType::GEOMETRY_TRIANGLES_NV,
34282             p_next: ::std::ptr::null(),
34283             vertex_data: Buffer::default(),
34284             vertex_offset: DeviceSize::default(),
34285             vertex_count: u32::default(),
34286             vertex_stride: DeviceSize::default(),
34287             vertex_format: Format::default(),
34288             index_data: Buffer::default(),
34289             index_offset: DeviceSize::default(),
34290             index_count: u32::default(),
34291             index_type: IndexType::default(),
34292             transform_data: Buffer::default(),
34293             transform_offset: DeviceSize::default(),
34294         }
34295     }
34296 }
34297 impl GeometryTrianglesNV {
builder<'a>() -> GeometryTrianglesNVBuilder<'a>34298     pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> {
34299         GeometryTrianglesNVBuilder {
34300             inner: GeometryTrianglesNV::default(),
34301             marker: ::std::marker::PhantomData,
34302         }
34303     }
34304 }
34305 #[repr(transparent)]
34306 pub struct GeometryTrianglesNVBuilder<'a> {
34307     inner: GeometryTrianglesNV,
34308     marker: ::std::marker::PhantomData<&'a ()>,
34309 }
34310 pub unsafe trait ExtendsGeometryTrianglesNV {}
34311 impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> {
34312     type Target = GeometryTrianglesNV;
deref(&self) -> &Self::Target34313     fn deref(&self) -> &Self::Target {
34314         &self.inner
34315     }
34316 }
34317 impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34318     fn deref_mut(&mut self) -> &mut Self::Target {
34319         &mut self.inner
34320     }
34321 }
34322 impl<'a> GeometryTrianglesNVBuilder<'a> {
vertex_data(mut self, vertex_data: Buffer) -> GeometryTrianglesNVBuilder<'a>34323     pub fn vertex_data(mut self, vertex_data: Buffer) -> GeometryTrianglesNVBuilder<'a> {
34324         self.inner.vertex_data = vertex_data;
34325         self
34326     }
vertex_offset(mut self, vertex_offset: DeviceSize) -> GeometryTrianglesNVBuilder<'a>34327     pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> GeometryTrianglesNVBuilder<'a> {
34328         self.inner.vertex_offset = vertex_offset;
34329         self
34330     }
vertex_count(mut self, vertex_count: u32) -> GeometryTrianglesNVBuilder<'a>34331     pub fn vertex_count(mut self, vertex_count: u32) -> GeometryTrianglesNVBuilder<'a> {
34332         self.inner.vertex_count = vertex_count;
34333         self
34334     }
vertex_stride(mut self, vertex_stride: DeviceSize) -> GeometryTrianglesNVBuilder<'a>34335     pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> GeometryTrianglesNVBuilder<'a> {
34336         self.inner.vertex_stride = vertex_stride;
34337         self
34338     }
vertex_format(mut self, vertex_format: Format) -> GeometryTrianglesNVBuilder<'a>34339     pub fn vertex_format(mut self, vertex_format: Format) -> GeometryTrianglesNVBuilder<'a> {
34340         self.inner.vertex_format = vertex_format;
34341         self
34342     }
index_data(mut self, index_data: Buffer) -> GeometryTrianglesNVBuilder<'a>34343     pub fn index_data(mut self, index_data: Buffer) -> GeometryTrianglesNVBuilder<'a> {
34344         self.inner.index_data = index_data;
34345         self
34346     }
index_offset(mut self, index_offset: DeviceSize) -> GeometryTrianglesNVBuilder<'a>34347     pub fn index_offset(mut self, index_offset: DeviceSize) -> GeometryTrianglesNVBuilder<'a> {
34348         self.inner.index_offset = index_offset;
34349         self
34350     }
index_count(mut self, index_count: u32) -> GeometryTrianglesNVBuilder<'a>34351     pub fn index_count(mut self, index_count: u32) -> GeometryTrianglesNVBuilder<'a> {
34352         self.inner.index_count = index_count;
34353         self
34354     }
index_type(mut self, index_type: IndexType) -> GeometryTrianglesNVBuilder<'a>34355     pub fn index_type(mut self, index_type: IndexType) -> GeometryTrianglesNVBuilder<'a> {
34356         self.inner.index_type = index_type;
34357         self
34358     }
transform_data(mut self, transform_data: Buffer) -> GeometryTrianglesNVBuilder<'a>34359     pub fn transform_data(mut self, transform_data: Buffer) -> GeometryTrianglesNVBuilder<'a> {
34360         self.inner.transform_data = transform_data;
34361         self
34362     }
transform_offset( mut self, transform_offset: DeviceSize, ) -> GeometryTrianglesNVBuilder<'a>34363     pub fn transform_offset(
34364         mut self,
34365         transform_offset: DeviceSize,
34366     ) -> GeometryTrianglesNVBuilder<'a> {
34367         self.inner.transform_offset = transform_offset;
34368         self
34369     }
34370     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34371     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34372     #[doc = r" valid extension structs can be pushed into the chain."]
34373     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34374     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGeometryTrianglesNV>( mut self, next: &'a mut T, ) -> GeometryTrianglesNVBuilder<'a>34375     pub fn push_next<T: ExtendsGeometryTrianglesNV>(
34376         mut self,
34377         next: &'a mut T,
34378     ) -> GeometryTrianglesNVBuilder<'a> {
34379         unsafe {
34380             let next_ptr = next as *mut T as *mut BaseOutStructure;
34381             let last_next = ptr_chain_iter(next).last().unwrap();
34382             (*last_next).p_next = self.inner.p_next as _;
34383             self.inner.p_next = next_ptr as _;
34384         }
34385         self
34386     }
34387     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34388     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34389     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryTrianglesNV34390     pub fn build(self) -> GeometryTrianglesNV {
34391         self.inner
34392     }
34393 }
34394 #[repr(C)]
34395 #[derive(Copy, Clone, Debug)]
34396 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryAABBNV.html>"]
34397 pub struct GeometryAABBNV {
34398     pub s_type: StructureType,
34399     pub p_next: *const c_void,
34400     pub aabb_data: Buffer,
34401     pub num_aab_bs: u32,
34402     pub stride: u32,
34403     pub offset: DeviceSize,
34404 }
34405 impl ::std::default::Default for GeometryAABBNV {
default() -> GeometryAABBNV34406     fn default() -> GeometryAABBNV {
34407         GeometryAABBNV {
34408             s_type: StructureType::GEOMETRY_AABB_NV,
34409             p_next: ::std::ptr::null(),
34410             aabb_data: Buffer::default(),
34411             num_aab_bs: u32::default(),
34412             stride: u32::default(),
34413             offset: DeviceSize::default(),
34414         }
34415     }
34416 }
34417 impl GeometryAABBNV {
builder<'a>() -> GeometryAABBNVBuilder<'a>34418     pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> {
34419         GeometryAABBNVBuilder {
34420             inner: GeometryAABBNV::default(),
34421             marker: ::std::marker::PhantomData,
34422         }
34423     }
34424 }
34425 #[repr(transparent)]
34426 pub struct GeometryAABBNVBuilder<'a> {
34427     inner: GeometryAABBNV,
34428     marker: ::std::marker::PhantomData<&'a ()>,
34429 }
34430 pub unsafe trait ExtendsGeometryAABBNV {}
34431 impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> {
34432     type Target = GeometryAABBNV;
deref(&self) -> &Self::Target34433     fn deref(&self) -> &Self::Target {
34434         &self.inner
34435     }
34436 }
34437 impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34438     fn deref_mut(&mut self) -> &mut Self::Target {
34439         &mut self.inner
34440     }
34441 }
34442 impl<'a> GeometryAABBNVBuilder<'a> {
aabb_data(mut self, aabb_data: Buffer) -> GeometryAABBNVBuilder<'a>34443     pub fn aabb_data(mut self, aabb_data: Buffer) -> GeometryAABBNVBuilder<'a> {
34444         self.inner.aabb_data = aabb_data;
34445         self
34446     }
num_aab_bs(mut self, num_aab_bs: u32) -> GeometryAABBNVBuilder<'a>34447     pub fn num_aab_bs(mut self, num_aab_bs: u32) -> GeometryAABBNVBuilder<'a> {
34448         self.inner.num_aab_bs = num_aab_bs;
34449         self
34450     }
stride(mut self, stride: u32) -> GeometryAABBNVBuilder<'a>34451     pub fn stride(mut self, stride: u32) -> GeometryAABBNVBuilder<'a> {
34452         self.inner.stride = stride;
34453         self
34454     }
offset(mut self, offset: DeviceSize) -> GeometryAABBNVBuilder<'a>34455     pub fn offset(mut self, offset: DeviceSize) -> GeometryAABBNVBuilder<'a> {
34456         self.inner.offset = offset;
34457         self
34458     }
34459     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34460     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34461     #[doc = r" valid extension structs can be pushed into the chain."]
34462     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34463     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGeometryAABBNV>( mut self, next: &'a mut T, ) -> GeometryAABBNVBuilder<'a>34464     pub fn push_next<T: ExtendsGeometryAABBNV>(
34465         mut self,
34466         next: &'a mut T,
34467     ) -> GeometryAABBNVBuilder<'a> {
34468         unsafe {
34469             let next_ptr = next as *mut T as *mut BaseOutStructure;
34470             let last_next = ptr_chain_iter(next).last().unwrap();
34471             (*last_next).p_next = self.inner.p_next as _;
34472             self.inner.p_next = next_ptr as _;
34473         }
34474         self
34475     }
34476     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34477     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34478     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryAABBNV34479     pub fn build(self) -> GeometryAABBNV {
34480         self.inner
34481     }
34482 }
34483 #[repr(C)]
34484 #[derive(Copy, Clone, Default, Debug)]
34485 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryDataNV.html>"]
34486 pub struct GeometryDataNV {
34487     pub triangles: GeometryTrianglesNV,
34488     pub aabbs: GeometryAABBNV,
34489 }
34490 impl GeometryDataNV {
builder<'a>() -> GeometryDataNVBuilder<'a>34491     pub fn builder<'a>() -> GeometryDataNVBuilder<'a> {
34492         GeometryDataNVBuilder {
34493             inner: GeometryDataNV::default(),
34494             marker: ::std::marker::PhantomData,
34495         }
34496     }
34497 }
34498 #[repr(transparent)]
34499 pub struct GeometryDataNVBuilder<'a> {
34500     inner: GeometryDataNV,
34501     marker: ::std::marker::PhantomData<&'a ()>,
34502 }
34503 impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> {
34504     type Target = GeometryDataNV;
deref(&self) -> &Self::Target34505     fn deref(&self) -> &Self::Target {
34506         &self.inner
34507     }
34508 }
34509 impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34510     fn deref_mut(&mut self) -> &mut Self::Target {
34511         &mut self.inner
34512     }
34513 }
34514 impl<'a> GeometryDataNVBuilder<'a> {
triangles(mut self, triangles: GeometryTrianglesNV) -> GeometryDataNVBuilder<'a>34515     pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> GeometryDataNVBuilder<'a> {
34516         self.inner.triangles = triangles;
34517         self
34518     }
aabbs(mut self, aabbs: GeometryAABBNV) -> GeometryDataNVBuilder<'a>34519     pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> GeometryDataNVBuilder<'a> {
34520         self.inner.aabbs = aabbs;
34521         self
34522     }
34523     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34524     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34525     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryDataNV34526     pub fn build(self) -> GeometryDataNV {
34527         self.inner
34528     }
34529 }
34530 #[repr(C)]
34531 #[derive(Copy, Clone, Debug)]
34532 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryNV.html>"]
34533 pub struct GeometryNV {
34534     pub s_type: StructureType,
34535     pub p_next: *const c_void,
34536     pub geometry_type: GeometryTypeKHR,
34537     pub geometry: GeometryDataNV,
34538     pub flags: GeometryFlagsKHR,
34539 }
34540 impl ::std::default::Default for GeometryNV {
default() -> GeometryNV34541     fn default() -> GeometryNV {
34542         GeometryNV {
34543             s_type: StructureType::GEOMETRY_NV,
34544             p_next: ::std::ptr::null(),
34545             geometry_type: GeometryTypeKHR::default(),
34546             geometry: GeometryDataNV::default(),
34547             flags: GeometryFlagsKHR::default(),
34548         }
34549     }
34550 }
34551 impl GeometryNV {
builder<'a>() -> GeometryNVBuilder<'a>34552     pub fn builder<'a>() -> GeometryNVBuilder<'a> {
34553         GeometryNVBuilder {
34554             inner: GeometryNV::default(),
34555             marker: ::std::marker::PhantomData,
34556         }
34557     }
34558 }
34559 #[repr(transparent)]
34560 pub struct GeometryNVBuilder<'a> {
34561     inner: GeometryNV,
34562     marker: ::std::marker::PhantomData<&'a ()>,
34563 }
34564 pub unsafe trait ExtendsGeometryNV {}
34565 impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> {
34566     type Target = GeometryNV;
deref(&self) -> &Self::Target34567     fn deref(&self) -> &Self::Target {
34568         &self.inner
34569     }
34570 }
34571 impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34572     fn deref_mut(&mut self) -> &mut Self::Target {
34573         &mut self.inner
34574     }
34575 }
34576 impl<'a> GeometryNVBuilder<'a> {
geometry_type(mut self, geometry_type: GeometryTypeKHR) -> GeometryNVBuilder<'a>34577     pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> GeometryNVBuilder<'a> {
34578         self.inner.geometry_type = geometry_type;
34579         self
34580     }
geometry(mut self, geometry: GeometryDataNV) -> GeometryNVBuilder<'a>34581     pub fn geometry(mut self, geometry: GeometryDataNV) -> GeometryNVBuilder<'a> {
34582         self.inner.geometry = geometry;
34583         self
34584     }
flags(mut self, flags: GeometryFlagsKHR) -> GeometryNVBuilder<'a>34585     pub fn flags(mut self, flags: GeometryFlagsKHR) -> GeometryNVBuilder<'a> {
34586         self.inner.flags = flags;
34587         self
34588     }
34589     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34590     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34591     #[doc = r" valid extension structs can be pushed into the chain."]
34592     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34593     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsGeometryNV>(mut self, next: &'a mut T) -> GeometryNVBuilder<'a>34594     pub fn push_next<T: ExtendsGeometryNV>(mut self, next: &'a mut T) -> GeometryNVBuilder<'a> {
34595         unsafe {
34596             let next_ptr = next as *mut T as *mut BaseOutStructure;
34597             let last_next = ptr_chain_iter(next).last().unwrap();
34598             (*last_next).p_next = self.inner.p_next as _;
34599             self.inner.p_next = next_ptr as _;
34600         }
34601         self
34602     }
34603     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34604     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34605     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> GeometryNV34606     pub fn build(self) -> GeometryNV {
34607         self.inner
34608     }
34609 }
34610 #[repr(C)]
34611 #[derive(Copy, Clone, Debug)]
34612 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureInfoNV.html>"]
34613 pub struct AccelerationStructureInfoNV {
34614     pub s_type: StructureType,
34615     pub p_next: *const c_void,
34616     pub ty: AccelerationStructureTypeNV,
34617     pub flags: BuildAccelerationStructureFlagsNV,
34618     pub instance_count: u32,
34619     pub geometry_count: u32,
34620     pub p_geometries: *const GeometryNV,
34621 }
34622 impl ::std::default::Default for AccelerationStructureInfoNV {
default() -> AccelerationStructureInfoNV34623     fn default() -> AccelerationStructureInfoNV {
34624         AccelerationStructureInfoNV {
34625             s_type: StructureType::ACCELERATION_STRUCTURE_INFO_NV,
34626             p_next: ::std::ptr::null(),
34627             ty: AccelerationStructureTypeNV::default(),
34628             flags: BuildAccelerationStructureFlagsNV::default(),
34629             instance_count: u32::default(),
34630             geometry_count: u32::default(),
34631             p_geometries: ::std::ptr::null(),
34632         }
34633     }
34634 }
34635 impl AccelerationStructureInfoNV {
builder<'a>() -> AccelerationStructureInfoNVBuilder<'a>34636     pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> {
34637         AccelerationStructureInfoNVBuilder {
34638             inner: AccelerationStructureInfoNV::default(),
34639             marker: ::std::marker::PhantomData,
34640         }
34641     }
34642 }
34643 #[repr(transparent)]
34644 pub struct AccelerationStructureInfoNVBuilder<'a> {
34645     inner: AccelerationStructureInfoNV,
34646     marker: ::std::marker::PhantomData<&'a ()>,
34647 }
34648 pub unsafe trait ExtendsAccelerationStructureInfoNV {}
34649 impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> {
34650     type Target = AccelerationStructureInfoNV;
deref(&self) -> &Self::Target34651     fn deref(&self) -> &Self::Target {
34652         &self.inner
34653     }
34654 }
34655 impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34656     fn deref_mut(&mut self) -> &mut Self::Target {
34657         &mut self.inner
34658     }
34659 }
34660 impl<'a> AccelerationStructureInfoNVBuilder<'a> {
ty(mut self, ty: AccelerationStructureTypeNV) -> AccelerationStructureInfoNVBuilder<'a>34661     pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> AccelerationStructureInfoNVBuilder<'a> {
34662         self.inner.ty = ty;
34663         self
34664     }
flags( mut self, flags: BuildAccelerationStructureFlagsNV, ) -> AccelerationStructureInfoNVBuilder<'a>34665     pub fn flags(
34666         mut self,
34667         flags: BuildAccelerationStructureFlagsNV,
34668     ) -> AccelerationStructureInfoNVBuilder<'a> {
34669         self.inner.flags = flags;
34670         self
34671     }
instance_count(mut self, instance_count: u32) -> AccelerationStructureInfoNVBuilder<'a>34672     pub fn instance_count(mut self, instance_count: u32) -> AccelerationStructureInfoNVBuilder<'a> {
34673         self.inner.instance_count = instance_count;
34674         self
34675     }
geometries( mut self, geometries: &'a [GeometryNV], ) -> AccelerationStructureInfoNVBuilder<'a>34676     pub fn geometries(
34677         mut self,
34678         geometries: &'a [GeometryNV],
34679     ) -> AccelerationStructureInfoNVBuilder<'a> {
34680         self.inner.geometry_count = geometries.len() as _;
34681         self.inner.p_geometries = geometries.as_ptr();
34682         self
34683     }
34684     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34685     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34686     #[doc = r" valid extension structs can be pushed into the chain."]
34687     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34688     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureInfoNV>( mut self, next: &'a mut T, ) -> AccelerationStructureInfoNVBuilder<'a>34689     pub fn push_next<T: ExtendsAccelerationStructureInfoNV>(
34690         mut self,
34691         next: &'a mut T,
34692     ) -> AccelerationStructureInfoNVBuilder<'a> {
34693         unsafe {
34694             let next_ptr = next as *mut T as *mut BaseOutStructure;
34695             let last_next = ptr_chain_iter(next).last().unwrap();
34696             (*last_next).p_next = self.inner.p_next as _;
34697             self.inner.p_next = next_ptr as _;
34698         }
34699         self
34700     }
34701     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34702     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34703     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureInfoNV34704     pub fn build(self) -> AccelerationStructureInfoNV {
34705         self.inner
34706     }
34707 }
34708 #[repr(C)]
34709 #[derive(Copy, Clone, Debug)]
34710 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateInfoNV.html>"]
34711 pub struct AccelerationStructureCreateInfoNV {
34712     pub s_type: StructureType,
34713     pub p_next: *const c_void,
34714     pub compacted_size: DeviceSize,
34715     pub info: AccelerationStructureInfoNV,
34716 }
34717 impl ::std::default::Default for AccelerationStructureCreateInfoNV {
default() -> AccelerationStructureCreateInfoNV34718     fn default() -> AccelerationStructureCreateInfoNV {
34719         AccelerationStructureCreateInfoNV {
34720             s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV,
34721             p_next: ::std::ptr::null(),
34722             compacted_size: DeviceSize::default(),
34723             info: AccelerationStructureInfoNV::default(),
34724         }
34725     }
34726 }
34727 impl AccelerationStructureCreateInfoNV {
builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a>34728     pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> {
34729         AccelerationStructureCreateInfoNVBuilder {
34730             inner: AccelerationStructureCreateInfoNV::default(),
34731             marker: ::std::marker::PhantomData,
34732         }
34733     }
34734 }
34735 #[repr(transparent)]
34736 pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
34737     inner: AccelerationStructureCreateInfoNV,
34738     marker: ::std::marker::PhantomData<&'a ()>,
34739 }
34740 pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {}
34741 impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
34742     type Target = AccelerationStructureCreateInfoNV;
deref(&self) -> &Self::Target34743     fn deref(&self) -> &Self::Target {
34744         &self.inner
34745     }
34746 }
34747 impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34748     fn deref_mut(&mut self) -> &mut Self::Target {
34749         &mut self.inner
34750     }
34751 }
34752 impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
compacted_size( mut self, compacted_size: DeviceSize, ) -> AccelerationStructureCreateInfoNVBuilder<'a>34753     pub fn compacted_size(
34754         mut self,
34755         compacted_size: DeviceSize,
34756     ) -> AccelerationStructureCreateInfoNVBuilder<'a> {
34757         self.inner.compacted_size = compacted_size;
34758         self
34759     }
info( mut self, info: AccelerationStructureInfoNV, ) -> AccelerationStructureCreateInfoNVBuilder<'a>34760     pub fn info(
34761         mut self,
34762         info: AccelerationStructureInfoNV,
34763     ) -> AccelerationStructureCreateInfoNVBuilder<'a> {
34764         self.inner.info = info;
34765         self
34766     }
34767     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34768     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34769     #[doc = r" valid extension structs can be pushed into the chain."]
34770     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34771     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureCreateInfoNV>( mut self, next: &'a mut T, ) -> AccelerationStructureCreateInfoNVBuilder<'a>34772     pub fn push_next<T: ExtendsAccelerationStructureCreateInfoNV>(
34773         mut self,
34774         next: &'a mut T,
34775     ) -> AccelerationStructureCreateInfoNVBuilder<'a> {
34776         unsafe {
34777             let next_ptr = next as *mut T as *mut BaseOutStructure;
34778             let last_next = ptr_chain_iter(next).last().unwrap();
34779             (*last_next).p_next = self.inner.p_next as _;
34780             self.inner.p_next = next_ptr as _;
34781         }
34782         self
34783     }
34784     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34785     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34786     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureCreateInfoNV34787     pub fn build(self) -> AccelerationStructureCreateInfoNV {
34788         self.inner
34789     }
34790 }
34791 #[repr(C)]
34792 #[derive(Copy, Clone, Debug)]
34793 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindAccelerationStructureMemoryInfoNV.html>"]
34794 pub struct BindAccelerationStructureMemoryInfoNV {
34795     pub s_type: StructureType,
34796     pub p_next: *const c_void,
34797     pub acceleration_structure: AccelerationStructureNV,
34798     pub memory: DeviceMemory,
34799     pub memory_offset: DeviceSize,
34800     pub device_index_count: u32,
34801     pub p_device_indices: *const u32,
34802 }
34803 impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV {
default() -> BindAccelerationStructureMemoryInfoNV34804     fn default() -> BindAccelerationStructureMemoryInfoNV {
34805         BindAccelerationStructureMemoryInfoNV {
34806             s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
34807             p_next: ::std::ptr::null(),
34808             acceleration_structure: AccelerationStructureNV::default(),
34809             memory: DeviceMemory::default(),
34810             memory_offset: DeviceSize::default(),
34811             device_index_count: u32::default(),
34812             p_device_indices: ::std::ptr::null(),
34813         }
34814     }
34815 }
34816 impl BindAccelerationStructureMemoryInfoNV {
builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a>34817     pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34818         BindAccelerationStructureMemoryInfoNVBuilder {
34819             inner: BindAccelerationStructureMemoryInfoNV::default(),
34820             marker: ::std::marker::PhantomData,
34821         }
34822     }
34823 }
34824 #[repr(transparent)]
34825 pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34826     inner: BindAccelerationStructureMemoryInfoNV,
34827     marker: ::std::marker::PhantomData<&'a ()>,
34828 }
34829 pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoNV {}
34830 impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34831     type Target = BindAccelerationStructureMemoryInfoNV;
deref(&self) -> &Self::Target34832     fn deref(&self) -> &Self::Target {
34833         &self.inner
34834     }
34835 }
34836 impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34837     fn deref_mut(&mut self) -> &mut Self::Target {
34838         &mut self.inner
34839     }
34840 }
34841 impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
acceleration_structure( mut self, acceleration_structure: AccelerationStructureNV, ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a>34842     pub fn acceleration_structure(
34843         mut self,
34844         acceleration_structure: AccelerationStructureNV,
34845     ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34846         self.inner.acceleration_structure = acceleration_structure;
34847         self
34848     }
memory( mut self, memory: DeviceMemory, ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a>34849     pub fn memory(
34850         mut self,
34851         memory: DeviceMemory,
34852     ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34853         self.inner.memory = memory;
34854         self
34855     }
memory_offset( mut self, memory_offset: DeviceSize, ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a>34856     pub fn memory_offset(
34857         mut self,
34858         memory_offset: DeviceSize,
34859     ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34860         self.inner.memory_offset = memory_offset;
34861         self
34862     }
device_indices( mut self, device_indices: &'a [u32], ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a>34863     pub fn device_indices(
34864         mut self,
34865         device_indices: &'a [u32],
34866     ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34867         self.inner.device_index_count = device_indices.len() as _;
34868         self.inner.p_device_indices = device_indices.as_ptr();
34869         self
34870     }
34871     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
34872     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
34873     #[doc = r" valid extension structs can be pushed into the chain."]
34874     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
34875     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBindAccelerationStructureMemoryInfoNV>( mut self, next: &'a mut T, ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a>34876     pub fn push_next<T: ExtendsBindAccelerationStructureMemoryInfoNV>(
34877         mut self,
34878         next: &'a mut T,
34879     ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
34880         unsafe {
34881             let next_ptr = next as *mut T as *mut BaseOutStructure;
34882             let last_next = ptr_chain_iter(next).last().unwrap();
34883             (*last_next).p_next = self.inner.p_next as _;
34884             self.inner.p_next = next_ptr as _;
34885         }
34886         self
34887     }
34888     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34889     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34890     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BindAccelerationStructureMemoryInfoNV34891     pub fn build(self) -> BindAccelerationStructureMemoryInfoNV {
34892         self.inner
34893     }
34894 }
34895 #[repr(C)]
34896 #[derive(Copy, Clone, Debug)]
34897 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>"]
34898 pub struct WriteDescriptorSetAccelerationStructureKHR {
34899     pub s_type: StructureType,
34900     pub p_next: *const c_void,
34901     pub acceleration_structure_count: u32,
34902     pub p_acceleration_structures: *const AccelerationStructureKHR,
34903 }
34904 impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR {
default() -> WriteDescriptorSetAccelerationStructureKHR34905     fn default() -> WriteDescriptorSetAccelerationStructureKHR {
34906         WriteDescriptorSetAccelerationStructureKHR {
34907             s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
34908             p_next: ::std::ptr::null(),
34909             acceleration_structure_count: u32::default(),
34910             p_acceleration_structures: ::std::ptr::null(),
34911         }
34912     }
34913 }
34914 impl WriteDescriptorSetAccelerationStructureKHR {
builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a>34915     pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
34916         WriteDescriptorSetAccelerationStructureKHRBuilder {
34917             inner: WriteDescriptorSetAccelerationStructureKHR::default(),
34918             marker: ::std::marker::PhantomData,
34919         }
34920     }
34921 }
34922 #[repr(transparent)]
34923 pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
34924     inner: WriteDescriptorSetAccelerationStructureKHR,
34925     marker: ::std::marker::PhantomData<&'a ()>,
34926 }
34927 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {}
34928 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {}
34929 impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
34930     type Target = WriteDescriptorSetAccelerationStructureKHR;
deref(&self) -> &Self::Target34931     fn deref(&self) -> &Self::Target {
34932         &self.inner
34933     }
34934 }
34935 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34936     fn deref_mut(&mut self) -> &mut Self::Target {
34937         &mut self.inner
34938     }
34939 }
34940 impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
acceleration_structures( mut self, acceleration_structures: &'a [AccelerationStructureKHR], ) -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a>34941     pub fn acceleration_structures(
34942         mut self,
34943         acceleration_structures: &'a [AccelerationStructureKHR],
34944     ) -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
34945         self.inner.acceleration_structure_count = acceleration_structures.len() as _;
34946         self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
34947         self
34948     }
34949     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
34950     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
34951     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSetAccelerationStructureKHR34952     pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR {
34953         self.inner
34954     }
34955 }
34956 #[repr(C)]
34957 #[derive(Copy, Clone, Debug)]
34958 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetAccelerationStructureNV.html>"]
34959 pub struct WriteDescriptorSetAccelerationStructureNV {
34960     pub s_type: StructureType,
34961     pub p_next: *const c_void,
34962     pub acceleration_structure_count: u32,
34963     pub p_acceleration_structures: *const AccelerationStructureNV,
34964 }
34965 impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV {
default() -> WriteDescriptorSetAccelerationStructureNV34966     fn default() -> WriteDescriptorSetAccelerationStructureNV {
34967         WriteDescriptorSetAccelerationStructureNV {
34968             s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
34969             p_next: ::std::ptr::null(),
34970             acceleration_structure_count: u32::default(),
34971             p_acceleration_structures: ::std::ptr::null(),
34972         }
34973     }
34974 }
34975 impl WriteDescriptorSetAccelerationStructureNV {
builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a>34976     pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
34977         WriteDescriptorSetAccelerationStructureNVBuilder {
34978             inner: WriteDescriptorSetAccelerationStructureNV::default(),
34979             marker: ::std::marker::PhantomData,
34980         }
34981     }
34982 }
34983 #[repr(transparent)]
34984 pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
34985     inner: WriteDescriptorSetAccelerationStructureNV,
34986     marker: ::std::marker::PhantomData<&'a ()>,
34987 }
34988 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {}
34989 unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {}
34990 impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
34991     type Target = WriteDescriptorSetAccelerationStructureNV;
deref(&self) -> &Self::Target34992     fn deref(&self) -> &Self::Target {
34993         &self.inner
34994     }
34995 }
34996 impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target34997     fn deref_mut(&mut self) -> &mut Self::Target {
34998         &mut self.inner
34999     }
35000 }
35001 impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
acceleration_structures( mut self, acceleration_structures: &'a [AccelerationStructureNV], ) -> WriteDescriptorSetAccelerationStructureNVBuilder<'a>35002     pub fn acceleration_structures(
35003         mut self,
35004         acceleration_structures: &'a [AccelerationStructureNV],
35005     ) -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
35006         self.inner.acceleration_structure_count = acceleration_structures.len() as _;
35007         self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
35008         self
35009     }
35010     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35011     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35012     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> WriteDescriptorSetAccelerationStructureNV35013     pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV {
35014         self.inner
35015     }
35016 }
35017 #[repr(C)]
35018 #[derive(Copy, Clone, Debug)]
35019 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>"]
35020 pub struct AccelerationStructureMemoryRequirementsInfoNV {
35021     pub s_type: StructureType,
35022     pub p_next: *const c_void,
35023     pub ty: AccelerationStructureMemoryRequirementsTypeNV,
35024     pub acceleration_structure: AccelerationStructureNV,
35025 }
35026 impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV {
default() -> AccelerationStructureMemoryRequirementsInfoNV35027     fn default() -> AccelerationStructureMemoryRequirementsInfoNV {
35028         AccelerationStructureMemoryRequirementsInfoNV {
35029             s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
35030             p_next: ::std::ptr::null(),
35031             ty: AccelerationStructureMemoryRequirementsTypeNV::default(),
35032             acceleration_structure: AccelerationStructureNV::default(),
35033         }
35034     }
35035 }
35036 impl AccelerationStructureMemoryRequirementsInfoNV {
builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a>35037     pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
35038         AccelerationStructureMemoryRequirementsInfoNVBuilder {
35039             inner: AccelerationStructureMemoryRequirementsInfoNV::default(),
35040             marker: ::std::marker::PhantomData,
35041         }
35042     }
35043 }
35044 #[repr(transparent)]
35045 pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
35046     inner: AccelerationStructureMemoryRequirementsInfoNV,
35047     marker: ::std::marker::PhantomData<&'a ()>,
35048 }
35049 pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoNV {}
35050 impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
35051     type Target = AccelerationStructureMemoryRequirementsInfoNV;
deref(&self) -> &Self::Target35052     fn deref(&self) -> &Self::Target {
35053         &self.inner
35054     }
35055 }
35056 impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35057     fn deref_mut(&mut self) -> &mut Self::Target {
35058         &mut self.inner
35059     }
35060 }
35061 impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
ty( mut self, ty: AccelerationStructureMemoryRequirementsTypeNV, ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a>35062     pub fn ty(
35063         mut self,
35064         ty: AccelerationStructureMemoryRequirementsTypeNV,
35065     ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
35066         self.inner.ty = ty;
35067         self
35068     }
acceleration_structure( mut self, acceleration_structure: AccelerationStructureNV, ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a>35069     pub fn acceleration_structure(
35070         mut self,
35071         acceleration_structure: AccelerationStructureNV,
35072     ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
35073         self.inner.acceleration_structure = acceleration_structure;
35074         self
35075     }
35076     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
35077     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
35078     #[doc = r" valid extension structs can be pushed into the chain."]
35079     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
35080     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureMemoryRequirementsInfoNV>( mut self, next: &'a mut T, ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a>35081     pub fn push_next<T: ExtendsAccelerationStructureMemoryRequirementsInfoNV>(
35082         mut self,
35083         next: &'a mut T,
35084     ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
35085         unsafe {
35086             let next_ptr = next as *mut T as *mut BaseOutStructure;
35087             let last_next = ptr_chain_iter(next).last().unwrap();
35088             (*last_next).p_next = self.inner.p_next as _;
35089             self.inner.p_next = next_ptr as _;
35090         }
35091         self
35092     }
35093     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35094     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35095     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureMemoryRequirementsInfoNV35096     pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV {
35097         self.inner
35098     }
35099 }
35100 #[repr(C)]
35101 #[derive(Copy, Clone, Debug)]
35102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html>"]
35103 pub struct PhysicalDeviceAccelerationStructureFeaturesKHR {
35104     pub s_type: StructureType,
35105     pub p_next: *mut c_void,
35106     pub acceleration_structure: Bool32,
35107     pub acceleration_structure_capture_replay: Bool32,
35108     pub acceleration_structure_indirect_build: Bool32,
35109     pub acceleration_structure_host_commands: Bool32,
35110     pub descriptor_binding_acceleration_structure_update_after_bind: Bool32,
35111 }
35112 impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR {
default() -> PhysicalDeviceAccelerationStructureFeaturesKHR35113     fn default() -> PhysicalDeviceAccelerationStructureFeaturesKHR {
35114         PhysicalDeviceAccelerationStructureFeaturesKHR {
35115             s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
35116             p_next: ::std::ptr::null_mut(),
35117             acceleration_structure: Bool32::default(),
35118             acceleration_structure_capture_replay: Bool32::default(),
35119             acceleration_structure_indirect_build: Bool32::default(),
35120             acceleration_structure_host_commands: Bool32::default(),
35121             descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(),
35122         }
35123     }
35124 }
35125 impl PhysicalDeviceAccelerationStructureFeaturesKHR {
builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a>35126     pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35127         PhysicalDeviceAccelerationStructureFeaturesKHRBuilder {
35128             inner: PhysicalDeviceAccelerationStructureFeaturesKHR::default(),
35129             marker: ::std::marker::PhantomData,
35130         }
35131     }
35132 }
35133 #[repr(transparent)]
35134 pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35135     inner: PhysicalDeviceAccelerationStructureFeaturesKHR,
35136     marker: ::std::marker::PhantomData<&'a ()>,
35137 }
35138 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {}
35139 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {}
35140 impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35141     type Target = PhysicalDeviceAccelerationStructureFeaturesKHR;
deref(&self) -> &Self::Target35142     fn deref(&self) -> &Self::Target {
35143         &self.inner
35144     }
35145 }
35146 impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35147     fn deref_mut(&mut self) -> &mut Self::Target {
35148         &mut self.inner
35149     }
35150 }
35151 impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
acceleration_structure( mut self, acceleration_structure: bool, ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a>35152     pub fn acceleration_structure(
35153         mut self,
35154         acceleration_structure: bool,
35155     ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35156         self.inner.acceleration_structure = acceleration_structure.into();
35157         self
35158     }
acceleration_structure_capture_replay( mut self, acceleration_structure_capture_replay: bool, ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a>35159     pub fn acceleration_structure_capture_replay(
35160         mut self,
35161         acceleration_structure_capture_replay: bool,
35162     ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35163         self.inner.acceleration_structure_capture_replay =
35164             acceleration_structure_capture_replay.into();
35165         self
35166     }
acceleration_structure_indirect_build( mut self, acceleration_structure_indirect_build: bool, ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a>35167     pub fn acceleration_structure_indirect_build(
35168         mut self,
35169         acceleration_structure_indirect_build: bool,
35170     ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35171         self.inner.acceleration_structure_indirect_build =
35172             acceleration_structure_indirect_build.into();
35173         self
35174     }
acceleration_structure_host_commands( mut self, acceleration_structure_host_commands: bool, ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a>35175     pub fn acceleration_structure_host_commands(
35176         mut self,
35177         acceleration_structure_host_commands: bool,
35178     ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35179         self.inner.acceleration_structure_host_commands =
35180             acceleration_structure_host_commands.into();
35181         self
35182     }
descriptor_binding_acceleration_structure_update_after_bind( mut self, descriptor_binding_acceleration_structure_update_after_bind: bool, ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a>35183     pub fn descriptor_binding_acceleration_structure_update_after_bind(
35184         mut self,
35185         descriptor_binding_acceleration_structure_update_after_bind: bool,
35186     ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
35187         self.inner
35188             .descriptor_binding_acceleration_structure_update_after_bind =
35189             descriptor_binding_acceleration_structure_update_after_bind.into();
35190         self
35191     }
35192     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35193     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35194     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR35195     pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR {
35196         self.inner
35197     }
35198 }
35199 #[repr(C)]
35200 #[derive(Copy, Clone, Debug)]
35201 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html>"]
35202 pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
35203     pub s_type: StructureType,
35204     pub p_next: *mut c_void,
35205     pub ray_tracing_pipeline: Bool32,
35206     pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32,
35207     pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32,
35208     pub ray_tracing_pipeline_trace_rays_indirect: Bool32,
35209     pub ray_traversal_primitive_culling: Bool32,
35210 }
35211 impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR {
default() -> PhysicalDeviceRayTracingPipelineFeaturesKHR35212     fn default() -> PhysicalDeviceRayTracingPipelineFeaturesKHR {
35213         PhysicalDeviceRayTracingPipelineFeaturesKHR {
35214             s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
35215             p_next: ::std::ptr::null_mut(),
35216             ray_tracing_pipeline: Bool32::default(),
35217             ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(),
35218             ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(),
35219             ray_tracing_pipeline_trace_rays_indirect: Bool32::default(),
35220             ray_traversal_primitive_culling: Bool32::default(),
35221         }
35222     }
35223 }
35224 impl PhysicalDeviceRayTracingPipelineFeaturesKHR {
builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a>35225     pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35226         PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder {
35227             inner: PhysicalDeviceRayTracingPipelineFeaturesKHR::default(),
35228             marker: ::std::marker::PhantomData,
35229         }
35230     }
35231 }
35232 #[repr(transparent)]
35233 pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35234     inner: PhysicalDeviceRayTracingPipelineFeaturesKHR,
35235     marker: ::std::marker::PhantomData<&'a ()>,
35236 }
35237 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {}
35238 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {}
35239 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35240     type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR;
deref(&self) -> &Self::Target35241     fn deref(&self) -> &Self::Target {
35242         &self.inner
35243     }
35244 }
35245 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35246     fn deref_mut(&mut self) -> &mut Self::Target {
35247         &mut self.inner
35248     }
35249 }
35250 impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
ray_tracing_pipeline( mut self, ray_tracing_pipeline: bool, ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a>35251     pub fn ray_tracing_pipeline(
35252         mut self,
35253         ray_tracing_pipeline: bool,
35254     ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35255         self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into();
35256         self
35257     }
ray_tracing_pipeline_shader_group_handle_capture_replay( mut self, ray_tracing_pipeline_shader_group_handle_capture_replay: bool, ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a>35258     pub fn ray_tracing_pipeline_shader_group_handle_capture_replay(
35259         mut self,
35260         ray_tracing_pipeline_shader_group_handle_capture_replay: bool,
35261     ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35262         self.inner
35263             .ray_tracing_pipeline_shader_group_handle_capture_replay =
35264             ray_tracing_pipeline_shader_group_handle_capture_replay.into();
35265         self
35266     }
ray_tracing_pipeline_shader_group_handle_capture_replay_mixed( mut self, ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool, ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a>35267     pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed(
35268         mut self,
35269         ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool,
35270     ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35271         self.inner
35272             .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed =
35273             ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into();
35274         self
35275     }
ray_tracing_pipeline_trace_rays_indirect( mut self, ray_tracing_pipeline_trace_rays_indirect: bool, ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a>35276     pub fn ray_tracing_pipeline_trace_rays_indirect(
35277         mut self,
35278         ray_tracing_pipeline_trace_rays_indirect: bool,
35279     ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35280         self.inner.ray_tracing_pipeline_trace_rays_indirect =
35281             ray_tracing_pipeline_trace_rays_indirect.into();
35282         self
35283     }
ray_traversal_primitive_culling( mut self, ray_traversal_primitive_culling: bool, ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a>35284     pub fn ray_traversal_primitive_culling(
35285         mut self,
35286         ray_traversal_primitive_culling: bool,
35287     ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
35288         self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into();
35289         self
35290     }
35291     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35292     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35293     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR35294     pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR {
35295         self.inner
35296     }
35297 }
35298 #[repr(C)]
35299 #[derive(Copy, Clone, Debug)]
35300 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html>"]
35301 pub struct PhysicalDeviceRayQueryFeaturesKHR {
35302     pub s_type: StructureType,
35303     pub p_next: *mut c_void,
35304     pub ray_query: Bool32,
35305 }
35306 impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR {
default() -> PhysicalDeviceRayQueryFeaturesKHR35307     fn default() -> PhysicalDeviceRayQueryFeaturesKHR {
35308         PhysicalDeviceRayQueryFeaturesKHR {
35309             s_type: StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
35310             p_next: ::std::ptr::null_mut(),
35311             ray_query: Bool32::default(),
35312         }
35313     }
35314 }
35315 impl PhysicalDeviceRayQueryFeaturesKHR {
builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a>35316     pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
35317         PhysicalDeviceRayQueryFeaturesKHRBuilder {
35318             inner: PhysicalDeviceRayQueryFeaturesKHR::default(),
35319             marker: ::std::marker::PhantomData,
35320         }
35321     }
35322 }
35323 #[repr(transparent)]
35324 pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
35325     inner: PhysicalDeviceRayQueryFeaturesKHR,
35326     marker: ::std::marker::PhantomData<&'a ()>,
35327 }
35328 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {}
35329 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {}
35330 impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
35331     type Target = PhysicalDeviceRayQueryFeaturesKHR;
deref(&self) -> &Self::Target35332     fn deref(&self) -> &Self::Target {
35333         &self.inner
35334     }
35335 }
35336 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35337     fn deref_mut(&mut self) -> &mut Self::Target {
35338         &mut self.inner
35339     }
35340 }
35341 impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
ray_query(mut self, ray_query: bool) -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a>35342     pub fn ray_query(mut self, ray_query: bool) -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
35343         self.inner.ray_query = ray_query.into();
35344         self
35345     }
35346     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35347     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35348     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayQueryFeaturesKHR35349     pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR {
35350         self.inner
35351     }
35352 }
35353 #[repr(C)]
35354 #[derive(Copy, Clone, Debug)]
35355 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html>"]
35356 pub struct PhysicalDeviceAccelerationStructurePropertiesKHR {
35357     pub s_type: StructureType,
35358     pub p_next: *mut c_void,
35359     pub max_geometry_count: u64,
35360     pub max_instance_count: u64,
35361     pub max_primitive_count: u64,
35362     pub max_per_stage_descriptor_acceleration_structures: u32,
35363     pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
35364     pub max_descriptor_set_acceleration_structures: u32,
35365     pub max_descriptor_set_update_after_bind_acceleration_structures: u32,
35366     pub min_acceleration_structure_scratch_offset_alignment: u32,
35367 }
35368 impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR {
default() -> PhysicalDeviceAccelerationStructurePropertiesKHR35369     fn default() -> PhysicalDeviceAccelerationStructurePropertiesKHR {
35370         PhysicalDeviceAccelerationStructurePropertiesKHR {
35371             s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
35372             p_next: ::std::ptr::null_mut(),
35373             max_geometry_count: u64::default(),
35374             max_instance_count: u64::default(),
35375             max_primitive_count: u64::default(),
35376             max_per_stage_descriptor_acceleration_structures: u32::default(),
35377             max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(),
35378             max_descriptor_set_acceleration_structures: u32::default(),
35379             max_descriptor_set_update_after_bind_acceleration_structures: u32::default(),
35380             min_acceleration_structure_scratch_offset_alignment: u32::default(),
35381         }
35382     }
35383 }
35384 impl PhysicalDeviceAccelerationStructurePropertiesKHR {
builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35385     pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35386         PhysicalDeviceAccelerationStructurePropertiesKHRBuilder {
35387             inner: PhysicalDeviceAccelerationStructurePropertiesKHR::default(),
35388             marker: ::std::marker::PhantomData,
35389         }
35390     }
35391 }
35392 #[repr(transparent)]
35393 pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35394     inner: PhysicalDeviceAccelerationStructurePropertiesKHR,
35395     marker: ::std::marker::PhantomData<&'a ()>,
35396 }
35397 unsafe impl ExtendsPhysicalDeviceProperties2
35398     for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_>
35399 {
35400 }
35401 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {}
35402 impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35403     type Target = PhysicalDeviceAccelerationStructurePropertiesKHR;
deref(&self) -> &Self::Target35404     fn deref(&self) -> &Self::Target {
35405         &self.inner
35406     }
35407 }
35408 impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35409     fn deref_mut(&mut self) -> &mut Self::Target {
35410         &mut self.inner
35411     }
35412 }
35413 impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
max_geometry_count( mut self, max_geometry_count: u64, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35414     pub fn max_geometry_count(
35415         mut self,
35416         max_geometry_count: u64,
35417     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35418         self.inner.max_geometry_count = max_geometry_count;
35419         self
35420     }
max_instance_count( mut self, max_instance_count: u64, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35421     pub fn max_instance_count(
35422         mut self,
35423         max_instance_count: u64,
35424     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35425         self.inner.max_instance_count = max_instance_count;
35426         self
35427     }
max_primitive_count( mut self, max_primitive_count: u64, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35428     pub fn max_primitive_count(
35429         mut self,
35430         max_primitive_count: u64,
35431     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35432         self.inner.max_primitive_count = max_primitive_count;
35433         self
35434     }
max_per_stage_descriptor_acceleration_structures( mut self, max_per_stage_descriptor_acceleration_structures: u32, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35435     pub fn max_per_stage_descriptor_acceleration_structures(
35436         mut self,
35437         max_per_stage_descriptor_acceleration_structures: u32,
35438     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35439         self.inner.max_per_stage_descriptor_acceleration_structures =
35440             max_per_stage_descriptor_acceleration_structures;
35441         self
35442     }
max_per_stage_descriptor_update_after_bind_acceleration_structures( mut self, max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35443     pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures(
35444         mut self,
35445         max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
35446     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35447         self.inner
35448             .max_per_stage_descriptor_update_after_bind_acceleration_structures =
35449             max_per_stage_descriptor_update_after_bind_acceleration_structures;
35450         self
35451     }
max_descriptor_set_acceleration_structures( mut self, max_descriptor_set_acceleration_structures: u32, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35452     pub fn max_descriptor_set_acceleration_structures(
35453         mut self,
35454         max_descriptor_set_acceleration_structures: u32,
35455     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35456         self.inner.max_descriptor_set_acceleration_structures =
35457             max_descriptor_set_acceleration_structures;
35458         self
35459     }
max_descriptor_set_update_after_bind_acceleration_structures( mut self, max_descriptor_set_update_after_bind_acceleration_structures: u32, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35460     pub fn max_descriptor_set_update_after_bind_acceleration_structures(
35461         mut self,
35462         max_descriptor_set_update_after_bind_acceleration_structures: u32,
35463     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35464         self.inner
35465             .max_descriptor_set_update_after_bind_acceleration_structures =
35466             max_descriptor_set_update_after_bind_acceleration_structures;
35467         self
35468     }
min_acceleration_structure_scratch_offset_alignment( mut self, min_acceleration_structure_scratch_offset_alignment: u32, ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a>35469     pub fn min_acceleration_structure_scratch_offset_alignment(
35470         mut self,
35471         min_acceleration_structure_scratch_offset_alignment: u32,
35472     ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
35473         self.inner
35474             .min_acceleration_structure_scratch_offset_alignment =
35475             min_acceleration_structure_scratch_offset_alignment;
35476         self
35477     }
35478     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35479     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35480     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR35481     pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR {
35482         self.inner
35483     }
35484 }
35485 #[repr(C)]
35486 #[derive(Copy, Clone, Debug)]
35487 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html>"]
35488 pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
35489     pub s_type: StructureType,
35490     pub p_next: *mut c_void,
35491     pub shader_group_handle_size: u32,
35492     pub max_ray_recursion_depth: u32,
35493     pub max_shader_group_stride: u32,
35494     pub shader_group_base_alignment: u32,
35495     pub shader_group_handle_capture_replay_size: u32,
35496     pub max_ray_dispatch_invocation_count: u32,
35497     pub shader_group_handle_alignment: u32,
35498     pub max_ray_hit_attribute_size: u32,
35499 }
35500 impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR {
default() -> PhysicalDeviceRayTracingPipelinePropertiesKHR35501     fn default() -> PhysicalDeviceRayTracingPipelinePropertiesKHR {
35502         PhysicalDeviceRayTracingPipelinePropertiesKHR {
35503             s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
35504             p_next: ::std::ptr::null_mut(),
35505             shader_group_handle_size: u32::default(),
35506             max_ray_recursion_depth: u32::default(),
35507             max_shader_group_stride: u32::default(),
35508             shader_group_base_alignment: u32::default(),
35509             shader_group_handle_capture_replay_size: u32::default(),
35510             max_ray_dispatch_invocation_count: u32::default(),
35511             shader_group_handle_alignment: u32::default(),
35512             max_ray_hit_attribute_size: u32::default(),
35513         }
35514     }
35515 }
35516 impl PhysicalDeviceRayTracingPipelinePropertiesKHR {
builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35517     pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35518         PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder {
35519             inner: PhysicalDeviceRayTracingPipelinePropertiesKHR::default(),
35520             marker: ::std::marker::PhantomData,
35521         }
35522     }
35523 }
35524 #[repr(transparent)]
35525 pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35526     inner: PhysicalDeviceRayTracingPipelinePropertiesKHR,
35527     marker: ::std::marker::PhantomData<&'a ()>,
35528 }
35529 unsafe impl ExtendsPhysicalDeviceProperties2
35530     for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_>
35531 {
35532 }
35533 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {}
35534 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35535     type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR;
deref(&self) -> &Self::Target35536     fn deref(&self) -> &Self::Target {
35537         &self.inner
35538     }
35539 }
35540 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35541     fn deref_mut(&mut self) -> &mut Self::Target {
35542         &mut self.inner
35543     }
35544 }
35545 impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
shader_group_handle_size( mut self, shader_group_handle_size: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35546     pub fn shader_group_handle_size(
35547         mut self,
35548         shader_group_handle_size: u32,
35549     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35550         self.inner.shader_group_handle_size = shader_group_handle_size;
35551         self
35552     }
max_ray_recursion_depth( mut self, max_ray_recursion_depth: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35553     pub fn max_ray_recursion_depth(
35554         mut self,
35555         max_ray_recursion_depth: u32,
35556     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35557         self.inner.max_ray_recursion_depth = max_ray_recursion_depth;
35558         self
35559     }
max_shader_group_stride( mut self, max_shader_group_stride: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35560     pub fn max_shader_group_stride(
35561         mut self,
35562         max_shader_group_stride: u32,
35563     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35564         self.inner.max_shader_group_stride = max_shader_group_stride;
35565         self
35566     }
shader_group_base_alignment( mut self, shader_group_base_alignment: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35567     pub fn shader_group_base_alignment(
35568         mut self,
35569         shader_group_base_alignment: u32,
35570     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35571         self.inner.shader_group_base_alignment = shader_group_base_alignment;
35572         self
35573     }
shader_group_handle_capture_replay_size( mut self, shader_group_handle_capture_replay_size: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35574     pub fn shader_group_handle_capture_replay_size(
35575         mut self,
35576         shader_group_handle_capture_replay_size: u32,
35577     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35578         self.inner.shader_group_handle_capture_replay_size =
35579             shader_group_handle_capture_replay_size;
35580         self
35581     }
max_ray_dispatch_invocation_count( mut self, max_ray_dispatch_invocation_count: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35582     pub fn max_ray_dispatch_invocation_count(
35583         mut self,
35584         max_ray_dispatch_invocation_count: u32,
35585     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35586         self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count;
35587         self
35588     }
shader_group_handle_alignment( mut self, shader_group_handle_alignment: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35589     pub fn shader_group_handle_alignment(
35590         mut self,
35591         shader_group_handle_alignment: u32,
35592     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35593         self.inner.shader_group_handle_alignment = shader_group_handle_alignment;
35594         self
35595     }
max_ray_hit_attribute_size( mut self, max_ray_hit_attribute_size: u32, ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a>35596     pub fn max_ray_hit_attribute_size(
35597         mut self,
35598         max_ray_hit_attribute_size: u32,
35599     ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
35600         self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size;
35601         self
35602     }
35603     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35604     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35605     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR35606     pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR {
35607         self.inner
35608     }
35609 }
35610 #[repr(C)]
35611 #[derive(Copy, Clone, Debug)]
35612 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>"]
35613 pub struct PhysicalDeviceRayTracingPropertiesNV {
35614     pub s_type: StructureType,
35615     pub p_next: *mut c_void,
35616     pub shader_group_handle_size: u32,
35617     pub max_recursion_depth: u32,
35618     pub max_shader_group_stride: u32,
35619     pub shader_group_base_alignment: u32,
35620     pub max_geometry_count: u64,
35621     pub max_instance_count: u64,
35622     pub max_triangle_count: u64,
35623     pub max_descriptor_set_acceleration_structures: u32,
35624 }
35625 impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV {
default() -> PhysicalDeviceRayTracingPropertiesNV35626     fn default() -> PhysicalDeviceRayTracingPropertiesNV {
35627         PhysicalDeviceRayTracingPropertiesNV {
35628             s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
35629             p_next: ::std::ptr::null_mut(),
35630             shader_group_handle_size: u32::default(),
35631             max_recursion_depth: u32::default(),
35632             max_shader_group_stride: u32::default(),
35633             shader_group_base_alignment: u32::default(),
35634             max_geometry_count: u64::default(),
35635             max_instance_count: u64::default(),
35636             max_triangle_count: u64::default(),
35637             max_descriptor_set_acceleration_structures: u32::default(),
35638         }
35639     }
35640 }
35641 impl PhysicalDeviceRayTracingPropertiesNV {
builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35642     pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35643         PhysicalDeviceRayTracingPropertiesNVBuilder {
35644             inner: PhysicalDeviceRayTracingPropertiesNV::default(),
35645             marker: ::std::marker::PhantomData,
35646         }
35647     }
35648 }
35649 #[repr(transparent)]
35650 pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35651     inner: PhysicalDeviceRayTracingPropertiesNV,
35652     marker: ::std::marker::PhantomData<&'a ()>,
35653 }
35654 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {}
35655 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {}
35656 impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35657     type Target = PhysicalDeviceRayTracingPropertiesNV;
deref(&self) -> &Self::Target35658     fn deref(&self) -> &Self::Target {
35659         &self.inner
35660     }
35661 }
35662 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35663     fn deref_mut(&mut self) -> &mut Self::Target {
35664         &mut self.inner
35665     }
35666 }
35667 impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
shader_group_handle_size( mut self, shader_group_handle_size: u32, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35668     pub fn shader_group_handle_size(
35669         mut self,
35670         shader_group_handle_size: u32,
35671     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35672         self.inner.shader_group_handle_size = shader_group_handle_size;
35673         self
35674     }
max_recursion_depth( mut self, max_recursion_depth: u32, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35675     pub fn max_recursion_depth(
35676         mut self,
35677         max_recursion_depth: u32,
35678     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35679         self.inner.max_recursion_depth = max_recursion_depth;
35680         self
35681     }
max_shader_group_stride( mut self, max_shader_group_stride: u32, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35682     pub fn max_shader_group_stride(
35683         mut self,
35684         max_shader_group_stride: u32,
35685     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35686         self.inner.max_shader_group_stride = max_shader_group_stride;
35687         self
35688     }
shader_group_base_alignment( mut self, shader_group_base_alignment: u32, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35689     pub fn shader_group_base_alignment(
35690         mut self,
35691         shader_group_base_alignment: u32,
35692     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35693         self.inner.shader_group_base_alignment = shader_group_base_alignment;
35694         self
35695     }
max_geometry_count( mut self, max_geometry_count: u64, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35696     pub fn max_geometry_count(
35697         mut self,
35698         max_geometry_count: u64,
35699     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35700         self.inner.max_geometry_count = max_geometry_count;
35701         self
35702     }
max_instance_count( mut self, max_instance_count: u64, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35703     pub fn max_instance_count(
35704         mut self,
35705         max_instance_count: u64,
35706     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35707         self.inner.max_instance_count = max_instance_count;
35708         self
35709     }
max_triangle_count( mut self, max_triangle_count: u64, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35710     pub fn max_triangle_count(
35711         mut self,
35712         max_triangle_count: u64,
35713     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35714         self.inner.max_triangle_count = max_triangle_count;
35715         self
35716     }
max_descriptor_set_acceleration_structures( mut self, max_descriptor_set_acceleration_structures: u32, ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a>35717     pub fn max_descriptor_set_acceleration_structures(
35718         mut self,
35719         max_descriptor_set_acceleration_structures: u32,
35720     ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
35721         self.inner.max_descriptor_set_acceleration_structures =
35722             max_descriptor_set_acceleration_structures;
35723         self
35724     }
35725     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35726     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35727     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRayTracingPropertiesNV35728     pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV {
35729         self.inner
35730     }
35731 }
35732 #[repr(C)]
35733 #[derive(Copy, Clone, Default, Debug)]
35734 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStridedDeviceAddressRegionKHR.html>"]
35735 pub struct StridedDeviceAddressRegionKHR {
35736     pub device_address: DeviceAddress,
35737     pub stride: DeviceSize,
35738     pub size: DeviceSize,
35739 }
35740 impl StridedDeviceAddressRegionKHR {
builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a>35741     pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> {
35742         StridedDeviceAddressRegionKHRBuilder {
35743             inner: StridedDeviceAddressRegionKHR::default(),
35744             marker: ::std::marker::PhantomData,
35745         }
35746     }
35747 }
35748 #[repr(transparent)]
35749 pub struct StridedDeviceAddressRegionKHRBuilder<'a> {
35750     inner: StridedDeviceAddressRegionKHR,
35751     marker: ::std::marker::PhantomData<&'a ()>,
35752 }
35753 impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> {
35754     type Target = StridedDeviceAddressRegionKHR;
deref(&self) -> &Self::Target35755     fn deref(&self) -> &Self::Target {
35756         &self.inner
35757     }
35758 }
35759 impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35760     fn deref_mut(&mut self) -> &mut Self::Target {
35761         &mut self.inner
35762     }
35763 }
35764 impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> {
device_address( mut self, device_address: DeviceAddress, ) -> StridedDeviceAddressRegionKHRBuilder<'a>35765     pub fn device_address(
35766         mut self,
35767         device_address: DeviceAddress,
35768     ) -> StridedDeviceAddressRegionKHRBuilder<'a> {
35769         self.inner.device_address = device_address;
35770         self
35771     }
stride(mut self, stride: DeviceSize) -> StridedDeviceAddressRegionKHRBuilder<'a>35772     pub fn stride(mut self, stride: DeviceSize) -> StridedDeviceAddressRegionKHRBuilder<'a> {
35773         self.inner.stride = stride;
35774         self
35775     }
size(mut self, size: DeviceSize) -> StridedDeviceAddressRegionKHRBuilder<'a>35776     pub fn size(mut self, size: DeviceSize) -> StridedDeviceAddressRegionKHRBuilder<'a> {
35777         self.inner.size = size;
35778         self
35779     }
35780     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35781     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35782     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> StridedDeviceAddressRegionKHR35783     pub fn build(self) -> StridedDeviceAddressRegionKHR {
35784         self.inner
35785     }
35786 }
35787 #[repr(C)]
35788 #[derive(Copy, Clone, Default, Debug)]
35789 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTraceRaysIndirectCommandKHR.html>"]
35790 pub struct TraceRaysIndirectCommandKHR {
35791     pub width: u32,
35792     pub height: u32,
35793     pub depth: u32,
35794 }
35795 impl TraceRaysIndirectCommandKHR {
builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a>35796     pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> {
35797         TraceRaysIndirectCommandKHRBuilder {
35798             inner: TraceRaysIndirectCommandKHR::default(),
35799             marker: ::std::marker::PhantomData,
35800         }
35801     }
35802 }
35803 #[repr(transparent)]
35804 pub struct TraceRaysIndirectCommandKHRBuilder<'a> {
35805     inner: TraceRaysIndirectCommandKHR,
35806     marker: ::std::marker::PhantomData<&'a ()>,
35807 }
35808 impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> {
35809     type Target = TraceRaysIndirectCommandKHR;
deref(&self) -> &Self::Target35810     fn deref(&self) -> &Self::Target {
35811         &self.inner
35812     }
35813 }
35814 impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35815     fn deref_mut(&mut self) -> &mut Self::Target {
35816         &mut self.inner
35817     }
35818 }
35819 impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> {
width(mut self, width: u32) -> TraceRaysIndirectCommandKHRBuilder<'a>35820     pub fn width(mut self, width: u32) -> TraceRaysIndirectCommandKHRBuilder<'a> {
35821         self.inner.width = width;
35822         self
35823     }
height(mut self, height: u32) -> TraceRaysIndirectCommandKHRBuilder<'a>35824     pub fn height(mut self, height: u32) -> TraceRaysIndirectCommandKHRBuilder<'a> {
35825         self.inner.height = height;
35826         self
35827     }
depth(mut self, depth: u32) -> TraceRaysIndirectCommandKHRBuilder<'a>35828     pub fn depth(mut self, depth: u32) -> TraceRaysIndirectCommandKHRBuilder<'a> {
35829         self.inner.depth = depth;
35830         self
35831     }
35832     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35833     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35834     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> TraceRaysIndirectCommandKHR35835     pub fn build(self) -> TraceRaysIndirectCommandKHR {
35836         self.inner
35837     }
35838 }
35839 #[repr(C)]
35840 #[derive(Copy, Clone, Debug)]
35841 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html>"]
35842 pub struct DrmFormatModifierPropertiesListEXT {
35843     pub s_type: StructureType,
35844     pub p_next: *mut c_void,
35845     pub drm_format_modifier_count: u32,
35846     pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
35847 }
35848 impl ::std::default::Default for DrmFormatModifierPropertiesListEXT {
default() -> DrmFormatModifierPropertiesListEXT35849     fn default() -> DrmFormatModifierPropertiesListEXT {
35850         DrmFormatModifierPropertiesListEXT {
35851             s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
35852             p_next: ::std::ptr::null_mut(),
35853             drm_format_modifier_count: u32::default(),
35854             p_drm_format_modifier_properties: ::std::ptr::null_mut(),
35855         }
35856     }
35857 }
35858 impl DrmFormatModifierPropertiesListEXT {
builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a>35859     pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
35860         DrmFormatModifierPropertiesListEXTBuilder {
35861             inner: DrmFormatModifierPropertiesListEXT::default(),
35862             marker: ::std::marker::PhantomData,
35863         }
35864     }
35865 }
35866 #[repr(transparent)]
35867 pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> {
35868     inner: DrmFormatModifierPropertiesListEXT,
35869     marker: ::std::marker::PhantomData<&'a ()>,
35870 }
35871 unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {}
35872 unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {}
35873 impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> {
35874     type Target = DrmFormatModifierPropertiesListEXT;
deref(&self) -> &Self::Target35875     fn deref(&self) -> &Self::Target {
35876         &self.inner
35877     }
35878 }
35879 impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35880     fn deref_mut(&mut self) -> &mut Self::Target {
35881         &mut self.inner
35882     }
35883 }
35884 impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
drm_format_modifier_properties( mut self, drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT], ) -> DrmFormatModifierPropertiesListEXTBuilder<'a>35885     pub fn drm_format_modifier_properties(
35886         mut self,
35887         drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT],
35888     ) -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
35889         self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
35890         self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
35891         self
35892     }
35893     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35894     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35895     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrmFormatModifierPropertiesListEXT35896     pub fn build(self) -> DrmFormatModifierPropertiesListEXT {
35897         self.inner
35898     }
35899 }
35900 #[repr(C)]
35901 #[derive(Copy, Clone, Default, Debug)]
35902 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html>"]
35903 pub struct DrmFormatModifierPropertiesEXT {
35904     pub drm_format_modifier: u64,
35905     pub drm_format_modifier_plane_count: u32,
35906     pub drm_format_modifier_tiling_features: FormatFeatureFlags,
35907 }
35908 impl DrmFormatModifierPropertiesEXT {
builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a>35909     pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> {
35910         DrmFormatModifierPropertiesEXTBuilder {
35911             inner: DrmFormatModifierPropertiesEXT::default(),
35912             marker: ::std::marker::PhantomData,
35913         }
35914     }
35915 }
35916 #[repr(transparent)]
35917 pub struct DrmFormatModifierPropertiesEXTBuilder<'a> {
35918     inner: DrmFormatModifierPropertiesEXT,
35919     marker: ::std::marker::PhantomData<&'a ()>,
35920 }
35921 impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> {
35922     type Target = DrmFormatModifierPropertiesEXT;
deref(&self) -> &Self::Target35923     fn deref(&self) -> &Self::Target {
35924         &self.inner
35925     }
35926 }
35927 impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target35928     fn deref_mut(&mut self) -> &mut Self::Target {
35929         &mut self.inner
35930     }
35931 }
35932 impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> {
drm_format_modifier( mut self, drm_format_modifier: u64, ) -> DrmFormatModifierPropertiesEXTBuilder<'a>35933     pub fn drm_format_modifier(
35934         mut self,
35935         drm_format_modifier: u64,
35936     ) -> DrmFormatModifierPropertiesEXTBuilder<'a> {
35937         self.inner.drm_format_modifier = drm_format_modifier;
35938         self
35939     }
drm_format_modifier_plane_count( mut self, drm_format_modifier_plane_count: u32, ) -> DrmFormatModifierPropertiesEXTBuilder<'a>35940     pub fn drm_format_modifier_plane_count(
35941         mut self,
35942         drm_format_modifier_plane_count: u32,
35943     ) -> DrmFormatModifierPropertiesEXTBuilder<'a> {
35944         self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
35945         self
35946     }
drm_format_modifier_tiling_features( mut self, drm_format_modifier_tiling_features: FormatFeatureFlags, ) -> DrmFormatModifierPropertiesEXTBuilder<'a>35947     pub fn drm_format_modifier_tiling_features(
35948         mut self,
35949         drm_format_modifier_tiling_features: FormatFeatureFlags,
35950     ) -> DrmFormatModifierPropertiesEXTBuilder<'a> {
35951         self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
35952         self
35953     }
35954     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
35955     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
35956     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DrmFormatModifierPropertiesEXT35957     pub fn build(self) -> DrmFormatModifierPropertiesEXT {
35958         self.inner
35959     }
35960 }
35961 #[repr(C)]
35962 #[derive(Copy, Clone, Debug)]
35963 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>"]
35964 pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
35965     pub s_type: StructureType,
35966     pub p_next: *const c_void,
35967     pub drm_format_modifier: u64,
35968     pub sharing_mode: SharingMode,
35969     pub queue_family_index_count: u32,
35970     pub p_queue_family_indices: *const u32,
35971 }
35972 impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
default() -> PhysicalDeviceImageDrmFormatModifierInfoEXT35973     fn default() -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
35974         PhysicalDeviceImageDrmFormatModifierInfoEXT {
35975             s_type: StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
35976             p_next: ::std::ptr::null(),
35977             drm_format_modifier: u64::default(),
35978             sharing_mode: SharingMode::default(),
35979             queue_family_index_count: u32::default(),
35980             p_queue_family_indices: ::std::ptr::null(),
35981         }
35982     }
35983 }
35984 impl PhysicalDeviceImageDrmFormatModifierInfoEXT {
builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a>35985     pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
35986         PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder {
35987             inner: PhysicalDeviceImageDrmFormatModifierInfoEXT::default(),
35988             marker: ::std::marker::PhantomData,
35989         }
35990     }
35991 }
35992 #[repr(transparent)]
35993 pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
35994     inner: PhysicalDeviceImageDrmFormatModifierInfoEXT,
35995     marker: ::std::marker::PhantomData<&'a ()>,
35996 }
35997 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
35998     for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_>
35999 {
36000 }
36001 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {}
36002 impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
36003     type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT;
deref(&self) -> &Self::Target36004     fn deref(&self) -> &Self::Target {
36005         &self.inner
36006     }
36007 }
36008 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36009     fn deref_mut(&mut self) -> &mut Self::Target {
36010         &mut self.inner
36011     }
36012 }
36013 impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
drm_format_modifier( mut self, drm_format_modifier: u64, ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a>36014     pub fn drm_format_modifier(
36015         mut self,
36016         drm_format_modifier: u64,
36017     ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
36018         self.inner.drm_format_modifier = drm_format_modifier;
36019         self
36020     }
sharing_mode( mut self, sharing_mode: SharingMode, ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a>36021     pub fn sharing_mode(
36022         mut self,
36023         sharing_mode: SharingMode,
36024     ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
36025         self.inner.sharing_mode = sharing_mode;
36026         self
36027     }
queue_family_indices( mut self, queue_family_indices: &'a [u32], ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a>36028     pub fn queue_family_indices(
36029         mut self,
36030         queue_family_indices: &'a [u32],
36031     ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
36032         self.inner.queue_family_index_count = queue_family_indices.len() as _;
36033         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
36034         self
36035     }
36036     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36037     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36038     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT36039     pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
36040         self.inner
36041     }
36042 }
36043 #[repr(C)]
36044 #[derive(Copy, Clone, Debug)]
36045 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>"]
36046 pub struct ImageDrmFormatModifierListCreateInfoEXT {
36047     pub s_type: StructureType,
36048     pub p_next: *const c_void,
36049     pub drm_format_modifier_count: u32,
36050     pub p_drm_format_modifiers: *const u64,
36051 }
36052 impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT {
default() -> ImageDrmFormatModifierListCreateInfoEXT36053     fn default() -> ImageDrmFormatModifierListCreateInfoEXT {
36054         ImageDrmFormatModifierListCreateInfoEXT {
36055             s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
36056             p_next: ::std::ptr::null(),
36057             drm_format_modifier_count: u32::default(),
36058             p_drm_format_modifiers: ::std::ptr::null(),
36059         }
36060     }
36061 }
36062 impl ImageDrmFormatModifierListCreateInfoEXT {
builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a>36063     pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
36064         ImageDrmFormatModifierListCreateInfoEXTBuilder {
36065             inner: ImageDrmFormatModifierListCreateInfoEXT::default(),
36066             marker: ::std::marker::PhantomData,
36067         }
36068     }
36069 }
36070 #[repr(transparent)]
36071 pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
36072     inner: ImageDrmFormatModifierListCreateInfoEXT,
36073     marker: ::std::marker::PhantomData<&'a ()>,
36074 }
36075 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {}
36076 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {}
36077 impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
36078     type Target = ImageDrmFormatModifierListCreateInfoEXT;
deref(&self) -> &Self::Target36079     fn deref(&self) -> &Self::Target {
36080         &self.inner
36081     }
36082 }
36083 impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36084     fn deref_mut(&mut self) -> &mut Self::Target {
36085         &mut self.inner
36086     }
36087 }
36088 impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
drm_format_modifiers( mut self, drm_format_modifiers: &'a [u64], ) -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a>36089     pub fn drm_format_modifiers(
36090         mut self,
36091         drm_format_modifiers: &'a [u64],
36092     ) -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
36093         self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _;
36094         self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr();
36095         self
36096     }
36097     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36098     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36099     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageDrmFormatModifierListCreateInfoEXT36100     pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT {
36101         self.inner
36102     }
36103 }
36104 #[repr(C)]
36105 #[derive(Copy, Clone, Debug)]
36106 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>"]
36107 pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
36108     pub s_type: StructureType,
36109     pub p_next: *const c_void,
36110     pub drm_format_modifier: u64,
36111     pub drm_format_modifier_plane_count: u32,
36112     pub p_plane_layouts: *const SubresourceLayout,
36113 }
36114 impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
default() -> ImageDrmFormatModifierExplicitCreateInfoEXT36115     fn default() -> ImageDrmFormatModifierExplicitCreateInfoEXT {
36116         ImageDrmFormatModifierExplicitCreateInfoEXT {
36117             s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
36118             p_next: ::std::ptr::null(),
36119             drm_format_modifier: u64::default(),
36120             drm_format_modifier_plane_count: u32::default(),
36121             p_plane_layouts: ::std::ptr::null(),
36122         }
36123     }
36124 }
36125 impl ImageDrmFormatModifierExplicitCreateInfoEXT {
builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a>36126     pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
36127         ImageDrmFormatModifierExplicitCreateInfoEXTBuilder {
36128             inner: ImageDrmFormatModifierExplicitCreateInfoEXT::default(),
36129             marker: ::std::marker::PhantomData,
36130         }
36131     }
36132 }
36133 #[repr(transparent)]
36134 pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
36135     inner: ImageDrmFormatModifierExplicitCreateInfoEXT,
36136     marker: ::std::marker::PhantomData<&'a ()>,
36137 }
36138 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {}
36139 unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {}
36140 impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
36141     type Target = ImageDrmFormatModifierExplicitCreateInfoEXT;
deref(&self) -> &Self::Target36142     fn deref(&self) -> &Self::Target {
36143         &self.inner
36144     }
36145 }
36146 impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36147     fn deref_mut(&mut self) -> &mut Self::Target {
36148         &mut self.inner
36149     }
36150 }
36151 impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
drm_format_modifier( mut self, drm_format_modifier: u64, ) -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a>36152     pub fn drm_format_modifier(
36153         mut self,
36154         drm_format_modifier: u64,
36155     ) -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
36156         self.inner.drm_format_modifier = drm_format_modifier;
36157         self
36158     }
plane_layouts( mut self, plane_layouts: &'a [SubresourceLayout], ) -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a>36159     pub fn plane_layouts(
36160         mut self,
36161         plane_layouts: &'a [SubresourceLayout],
36162     ) -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
36163         self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _;
36164         self.inner.p_plane_layouts = plane_layouts.as_ptr();
36165         self
36166     }
36167     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36168     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36169     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT36170     pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT {
36171         self.inner
36172     }
36173 }
36174 #[repr(C)]
36175 #[derive(Copy, Clone, Debug)]
36176 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html>"]
36177 pub struct ImageDrmFormatModifierPropertiesEXT {
36178     pub s_type: StructureType,
36179     pub p_next: *mut c_void,
36180     pub drm_format_modifier: u64,
36181 }
36182 impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT {
default() -> ImageDrmFormatModifierPropertiesEXT36183     fn default() -> ImageDrmFormatModifierPropertiesEXT {
36184         ImageDrmFormatModifierPropertiesEXT {
36185             s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
36186             p_next: ::std::ptr::null_mut(),
36187             drm_format_modifier: u64::default(),
36188         }
36189     }
36190 }
36191 impl ImageDrmFormatModifierPropertiesEXT {
builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a>36192     pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
36193         ImageDrmFormatModifierPropertiesEXTBuilder {
36194             inner: ImageDrmFormatModifierPropertiesEXT::default(),
36195             marker: ::std::marker::PhantomData,
36196         }
36197     }
36198 }
36199 #[repr(transparent)]
36200 pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
36201     inner: ImageDrmFormatModifierPropertiesEXT,
36202     marker: ::std::marker::PhantomData<&'a ()>,
36203 }
36204 pub unsafe trait ExtendsImageDrmFormatModifierPropertiesEXT {}
36205 impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
36206     type Target = ImageDrmFormatModifierPropertiesEXT;
deref(&self) -> &Self::Target36207     fn deref(&self) -> &Self::Target {
36208         &self.inner
36209     }
36210 }
36211 impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36212     fn deref_mut(&mut self) -> &mut Self::Target {
36213         &mut self.inner
36214     }
36215 }
36216 impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
drm_format_modifier( mut self, drm_format_modifier: u64, ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a>36217     pub fn drm_format_modifier(
36218         mut self,
36219         drm_format_modifier: u64,
36220     ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
36221         self.inner.drm_format_modifier = drm_format_modifier;
36222         self
36223     }
36224     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
36225     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
36226     #[doc = r" valid extension structs can be pushed into the chain."]
36227     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
36228     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageDrmFormatModifierPropertiesEXT>( mut self, next: &'a mut T, ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a>36229     pub fn push_next<T: ExtendsImageDrmFormatModifierPropertiesEXT>(
36230         mut self,
36231         next: &'a mut T,
36232     ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
36233         unsafe {
36234             let next_ptr = next as *mut T as *mut BaseOutStructure;
36235             let last_next = ptr_chain_iter(next).last().unwrap();
36236             (*last_next).p_next = self.inner.p_next as _;
36237             self.inner.p_next = next_ptr as _;
36238         }
36239         self
36240     }
36241     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36242     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36243     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageDrmFormatModifierPropertiesEXT36244     pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT {
36245         self.inner
36246     }
36247 }
36248 #[repr(C)]
36249 #[derive(Copy, Clone, Debug)]
36250 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageStencilUsageCreateInfo.html>"]
36251 pub struct ImageStencilUsageCreateInfo {
36252     pub s_type: StructureType,
36253     pub p_next: *const c_void,
36254     pub stencil_usage: ImageUsageFlags,
36255 }
36256 impl ::std::default::Default for ImageStencilUsageCreateInfo {
default() -> ImageStencilUsageCreateInfo36257     fn default() -> ImageStencilUsageCreateInfo {
36258         ImageStencilUsageCreateInfo {
36259             s_type: StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO,
36260             p_next: ::std::ptr::null(),
36261             stencil_usage: ImageUsageFlags::default(),
36262         }
36263     }
36264 }
36265 impl ImageStencilUsageCreateInfo {
builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a>36266     pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> {
36267         ImageStencilUsageCreateInfoBuilder {
36268             inner: ImageStencilUsageCreateInfo::default(),
36269             marker: ::std::marker::PhantomData,
36270         }
36271     }
36272 }
36273 #[repr(transparent)]
36274 pub struct ImageStencilUsageCreateInfoBuilder<'a> {
36275     inner: ImageStencilUsageCreateInfo,
36276     marker: ::std::marker::PhantomData<&'a ()>,
36277 }
36278 unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {}
36279 unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {}
36280 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {}
36281 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {}
36282 impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> {
36283     type Target = ImageStencilUsageCreateInfo;
deref(&self) -> &Self::Target36284     fn deref(&self) -> &Self::Target {
36285         &self.inner
36286     }
36287 }
36288 impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36289     fn deref_mut(&mut self) -> &mut Self::Target {
36290         &mut self.inner
36291     }
36292 }
36293 impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
stencil_usage( mut self, stencil_usage: ImageUsageFlags, ) -> ImageStencilUsageCreateInfoBuilder<'a>36294     pub fn stencil_usage(
36295         mut self,
36296         stencil_usage: ImageUsageFlags,
36297     ) -> ImageStencilUsageCreateInfoBuilder<'a> {
36298         self.inner.stencil_usage = stencil_usage;
36299         self
36300     }
36301     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36302     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36303     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageStencilUsageCreateInfo36304     pub fn build(self) -> ImageStencilUsageCreateInfo {
36305         self.inner
36306     }
36307 }
36308 #[repr(C)]
36309 #[derive(Copy, Clone, Debug)]
36310 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>"]
36311 pub struct DeviceMemoryOverallocationCreateInfoAMD {
36312     pub s_type: StructureType,
36313     pub p_next: *const c_void,
36314     pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
36315 }
36316 impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD {
default() -> DeviceMemoryOverallocationCreateInfoAMD36317     fn default() -> DeviceMemoryOverallocationCreateInfoAMD {
36318         DeviceMemoryOverallocationCreateInfoAMD {
36319             s_type: StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
36320             p_next: ::std::ptr::null(),
36321             overallocation_behavior: MemoryOverallocationBehaviorAMD::default(),
36322         }
36323     }
36324 }
36325 impl DeviceMemoryOverallocationCreateInfoAMD {
builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a>36326     pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
36327         DeviceMemoryOverallocationCreateInfoAMDBuilder {
36328             inner: DeviceMemoryOverallocationCreateInfoAMD::default(),
36329             marker: ::std::marker::PhantomData,
36330         }
36331     }
36332 }
36333 #[repr(transparent)]
36334 pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
36335     inner: DeviceMemoryOverallocationCreateInfoAMD,
36336     marker: ::std::marker::PhantomData<&'a ()>,
36337 }
36338 unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {}
36339 unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {}
36340 impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
36341     type Target = DeviceMemoryOverallocationCreateInfoAMD;
deref(&self) -> &Self::Target36342     fn deref(&self) -> &Self::Target {
36343         &self.inner
36344     }
36345 }
36346 impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36347     fn deref_mut(&mut self) -> &mut Self::Target {
36348         &mut self.inner
36349     }
36350 }
36351 impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
overallocation_behavior( mut self, overallocation_behavior: MemoryOverallocationBehaviorAMD, ) -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a>36352     pub fn overallocation_behavior(
36353         mut self,
36354         overallocation_behavior: MemoryOverallocationBehaviorAMD,
36355     ) -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
36356         self.inner.overallocation_behavior = overallocation_behavior;
36357         self
36358     }
36359     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36360     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36361     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceMemoryOverallocationCreateInfoAMD36362     pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD {
36363         self.inner
36364     }
36365 }
36366 #[repr(C)]
36367 #[derive(Copy, Clone, Debug)]
36368 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>"]
36369 pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
36370     pub s_type: StructureType,
36371     pub p_next: *mut c_void,
36372     pub fragment_density_map: Bool32,
36373     pub fragment_density_map_dynamic: Bool32,
36374     pub fragment_density_map_non_subsampled_images: Bool32,
36375 }
36376 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
default() -> PhysicalDeviceFragmentDensityMapFeaturesEXT36377     fn default() -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
36378         PhysicalDeviceFragmentDensityMapFeaturesEXT {
36379             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
36380             p_next: ::std::ptr::null_mut(),
36381             fragment_density_map: Bool32::default(),
36382             fragment_density_map_dynamic: Bool32::default(),
36383             fragment_density_map_non_subsampled_images: Bool32::default(),
36384         }
36385     }
36386 }
36387 impl PhysicalDeviceFragmentDensityMapFeaturesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a>36388     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
36389         PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder {
36390             inner: PhysicalDeviceFragmentDensityMapFeaturesEXT::default(),
36391             marker: ::std::marker::PhantomData,
36392         }
36393     }
36394 }
36395 #[repr(transparent)]
36396 pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
36397     inner: PhysicalDeviceFragmentDensityMapFeaturesEXT,
36398     marker: ::std::marker::PhantomData<&'a ()>,
36399 }
36400 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {}
36401 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
36402 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
36403     type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT;
deref(&self) -> &Self::Target36404     fn deref(&self) -> &Self::Target {
36405         &self.inner
36406     }
36407 }
36408 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36409     fn deref_mut(&mut self) -> &mut Self::Target {
36410         &mut self.inner
36411     }
36412 }
36413 impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
fragment_density_map( mut self, fragment_density_map: bool, ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a>36414     pub fn fragment_density_map(
36415         mut self,
36416         fragment_density_map: bool,
36417     ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
36418         self.inner.fragment_density_map = fragment_density_map.into();
36419         self
36420     }
fragment_density_map_dynamic( mut self, fragment_density_map_dynamic: bool, ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a>36421     pub fn fragment_density_map_dynamic(
36422         mut self,
36423         fragment_density_map_dynamic: bool,
36424     ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
36425         self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into();
36426         self
36427     }
fragment_density_map_non_subsampled_images( mut self, fragment_density_map_non_subsampled_images: bool, ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a>36428     pub fn fragment_density_map_non_subsampled_images(
36429         mut self,
36430         fragment_density_map_non_subsampled_images: bool,
36431     ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
36432         self.inner.fragment_density_map_non_subsampled_images =
36433             fragment_density_map_non_subsampled_images.into();
36434         self
36435     }
36436     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36437     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36438     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT36439     pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
36440         self.inner
36441     }
36442 }
36443 #[repr(C)]
36444 #[derive(Copy, Clone, Debug)]
36445 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html>"]
36446 pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT {
36447     pub s_type: StructureType,
36448     pub p_next: *mut c_void,
36449     pub fragment_density_map_deferred: Bool32,
36450 }
36451 impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
default() -> PhysicalDeviceFragmentDensityMap2FeaturesEXT36452     fn default() -> PhysicalDeviceFragmentDensityMap2FeaturesEXT {
36453         PhysicalDeviceFragmentDensityMap2FeaturesEXT {
36454             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
36455             p_next: ::std::ptr::null_mut(),
36456             fragment_density_map_deferred: Bool32::default(),
36457         }
36458     }
36459 }
36460 impl PhysicalDeviceFragmentDensityMap2FeaturesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a>36461     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
36462         PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder {
36463             inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT::default(),
36464             marker: ::std::marker::PhantomData,
36465         }
36466     }
36467 }
36468 #[repr(transparent)]
36469 pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
36470     inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT,
36471     marker: ::std::marker::PhantomData<&'a ()>,
36472 }
36473 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {}
36474 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {}
36475 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
36476     type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
deref(&self) -> &Self::Target36477     fn deref(&self) -> &Self::Target {
36478         &self.inner
36479     }
36480 }
36481 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36482     fn deref_mut(&mut self) -> &mut Self::Target {
36483         &mut self.inner
36484     }
36485 }
36486 impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
fragment_density_map_deferred( mut self, fragment_density_map_deferred: bool, ) -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a>36487     pub fn fragment_density_map_deferred(
36488         mut self,
36489         fragment_density_map_deferred: bool,
36490     ) -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
36491         self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into();
36492         self
36493     }
36494     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36495     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36496     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT36497     pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT {
36498         self.inner
36499     }
36500 }
36501 #[repr(C)]
36502 #[derive(Copy, Clone, Debug)]
36503 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>"]
36504 pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
36505     pub s_type: StructureType,
36506     pub p_next: *mut c_void,
36507     pub min_fragment_density_texel_size: Extent2D,
36508     pub max_fragment_density_texel_size: Extent2D,
36509     pub fragment_density_invocations: Bool32,
36510 }
36511 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
default() -> PhysicalDeviceFragmentDensityMapPropertiesEXT36512     fn default() -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
36513         PhysicalDeviceFragmentDensityMapPropertiesEXT {
36514             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
36515             p_next: ::std::ptr::null_mut(),
36516             min_fragment_density_texel_size: Extent2D::default(),
36517             max_fragment_density_texel_size: Extent2D::default(),
36518             fragment_density_invocations: Bool32::default(),
36519         }
36520     }
36521 }
36522 impl PhysicalDeviceFragmentDensityMapPropertiesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a>36523     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
36524         PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder {
36525             inner: PhysicalDeviceFragmentDensityMapPropertiesEXT::default(),
36526             marker: ::std::marker::PhantomData,
36527         }
36528     }
36529 }
36530 #[repr(transparent)]
36531 pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
36532     inner: PhysicalDeviceFragmentDensityMapPropertiesEXT,
36533     marker: ::std::marker::PhantomData<&'a ()>,
36534 }
36535 unsafe impl ExtendsPhysicalDeviceProperties2
36536     for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_>
36537 {
36538 }
36539 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {}
36540 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
36541     type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT;
deref(&self) -> &Self::Target36542     fn deref(&self) -> &Self::Target {
36543         &self.inner
36544     }
36545 }
36546 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36547     fn deref_mut(&mut self) -> &mut Self::Target {
36548         &mut self.inner
36549     }
36550 }
36551 impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
min_fragment_density_texel_size( mut self, min_fragment_density_texel_size: Extent2D, ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a>36552     pub fn min_fragment_density_texel_size(
36553         mut self,
36554         min_fragment_density_texel_size: Extent2D,
36555     ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
36556         self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size;
36557         self
36558     }
max_fragment_density_texel_size( mut self, max_fragment_density_texel_size: Extent2D, ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a>36559     pub fn max_fragment_density_texel_size(
36560         mut self,
36561         max_fragment_density_texel_size: Extent2D,
36562     ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
36563         self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size;
36564         self
36565     }
fragment_density_invocations( mut self, fragment_density_invocations: bool, ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a>36566     pub fn fragment_density_invocations(
36567         mut self,
36568         fragment_density_invocations: bool,
36569     ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
36570         self.inner.fragment_density_invocations = fragment_density_invocations.into();
36571         self
36572     }
36573     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36574     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36575     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT36576     pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
36577         self.inner
36578     }
36579 }
36580 #[repr(C)]
36581 #[derive(Copy, Clone, Debug)]
36582 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html>"]
36583 pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
36584     pub s_type: StructureType,
36585     pub p_next: *mut c_void,
36586     pub subsampled_loads: Bool32,
36587     pub subsampled_coarse_reconstruction_early_access: Bool32,
36588     pub max_subsampled_array_layers: u32,
36589     pub max_descriptor_set_subsampled_samplers: u32,
36590 }
36591 impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
default() -> PhysicalDeviceFragmentDensityMap2PropertiesEXT36592     fn default() -> PhysicalDeviceFragmentDensityMap2PropertiesEXT {
36593         PhysicalDeviceFragmentDensityMap2PropertiesEXT {
36594             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
36595             p_next: ::std::ptr::null_mut(),
36596             subsampled_loads: Bool32::default(),
36597             subsampled_coarse_reconstruction_early_access: Bool32::default(),
36598             max_subsampled_array_layers: u32::default(),
36599             max_descriptor_set_subsampled_samplers: u32::default(),
36600         }
36601     }
36602 }
36603 impl PhysicalDeviceFragmentDensityMap2PropertiesEXT {
builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a>36604     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
36605         PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder {
36606             inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT::default(),
36607             marker: ::std::marker::PhantomData,
36608         }
36609     }
36610 }
36611 #[repr(transparent)]
36612 pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
36613     inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT,
36614     marker: ::std::marker::PhantomData<&'a ()>,
36615 }
36616 unsafe impl ExtendsPhysicalDeviceProperties2
36617     for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_>
36618 {
36619 }
36620 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {}
36621 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
36622     type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
deref(&self) -> &Self::Target36623     fn deref(&self) -> &Self::Target {
36624         &self.inner
36625     }
36626 }
36627 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36628     fn deref_mut(&mut self) -> &mut Self::Target {
36629         &mut self.inner
36630     }
36631 }
36632 impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
subsampled_loads( mut self, subsampled_loads: bool, ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a>36633     pub fn subsampled_loads(
36634         mut self,
36635         subsampled_loads: bool,
36636     ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
36637         self.inner.subsampled_loads = subsampled_loads.into();
36638         self
36639     }
subsampled_coarse_reconstruction_early_access( mut self, subsampled_coarse_reconstruction_early_access: bool, ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a>36640     pub fn subsampled_coarse_reconstruction_early_access(
36641         mut self,
36642         subsampled_coarse_reconstruction_early_access: bool,
36643     ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
36644         self.inner.subsampled_coarse_reconstruction_early_access =
36645             subsampled_coarse_reconstruction_early_access.into();
36646         self
36647     }
max_subsampled_array_layers( mut self, max_subsampled_array_layers: u32, ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a>36648     pub fn max_subsampled_array_layers(
36649         mut self,
36650         max_subsampled_array_layers: u32,
36651     ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
36652         self.inner.max_subsampled_array_layers = max_subsampled_array_layers;
36653         self
36654     }
max_descriptor_set_subsampled_samplers( mut self, max_descriptor_set_subsampled_samplers: u32, ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a>36655     pub fn max_descriptor_set_subsampled_samplers(
36656         mut self,
36657         max_descriptor_set_subsampled_samplers: u32,
36658     ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
36659         self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers;
36660         self
36661     }
36662     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36663     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36664     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT36665     pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT {
36666         self.inner
36667     }
36668 }
36669 #[repr(C)]
36670 #[derive(Copy, Clone, Debug)]
36671 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>"]
36672 pub struct RenderPassFragmentDensityMapCreateInfoEXT {
36673     pub s_type: StructureType,
36674     pub p_next: *const c_void,
36675     pub fragment_density_map_attachment: AttachmentReference,
36676 }
36677 impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT {
default() -> RenderPassFragmentDensityMapCreateInfoEXT36678     fn default() -> RenderPassFragmentDensityMapCreateInfoEXT {
36679         RenderPassFragmentDensityMapCreateInfoEXT {
36680             s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
36681             p_next: ::std::ptr::null(),
36682             fragment_density_map_attachment: AttachmentReference::default(),
36683         }
36684     }
36685 }
36686 impl RenderPassFragmentDensityMapCreateInfoEXT {
builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a>36687     pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
36688         RenderPassFragmentDensityMapCreateInfoEXTBuilder {
36689             inner: RenderPassFragmentDensityMapCreateInfoEXT::default(),
36690             marker: ::std::marker::PhantomData,
36691         }
36692     }
36693 }
36694 #[repr(transparent)]
36695 pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
36696     inner: RenderPassFragmentDensityMapCreateInfoEXT,
36697     marker: ::std::marker::PhantomData<&'a ()>,
36698 }
36699 unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
36700 unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {}
36701 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
36702 unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {}
36703 impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
36704     type Target = RenderPassFragmentDensityMapCreateInfoEXT;
deref(&self) -> &Self::Target36705     fn deref(&self) -> &Self::Target {
36706         &self.inner
36707     }
36708 }
36709 impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36710     fn deref_mut(&mut self) -> &mut Self::Target {
36711         &mut self.inner
36712     }
36713 }
36714 impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
fragment_density_map_attachment( mut self, fragment_density_map_attachment: AttachmentReference, ) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a>36715     pub fn fragment_density_map_attachment(
36716         mut self,
36717         fragment_density_map_attachment: AttachmentReference,
36718     ) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
36719         self.inner.fragment_density_map_attachment = fragment_density_map_attachment;
36720         self
36721     }
36722     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36723     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36724     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassFragmentDensityMapCreateInfoEXT36725     pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT {
36726         self.inner
36727     }
36728 }
36729 #[repr(C)]
36730 #[derive(Copy, Clone, Debug)]
36731 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>"]
36732 pub struct PhysicalDeviceScalarBlockLayoutFeatures {
36733     pub s_type: StructureType,
36734     pub p_next: *mut c_void,
36735     pub scalar_block_layout: Bool32,
36736 }
36737 impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures {
default() -> PhysicalDeviceScalarBlockLayoutFeatures36738     fn default() -> PhysicalDeviceScalarBlockLayoutFeatures {
36739         PhysicalDeviceScalarBlockLayoutFeatures {
36740             s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
36741             p_next: ::std::ptr::null_mut(),
36742             scalar_block_layout: Bool32::default(),
36743         }
36744     }
36745 }
36746 impl PhysicalDeviceScalarBlockLayoutFeatures {
builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a>36747     pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
36748         PhysicalDeviceScalarBlockLayoutFeaturesBuilder {
36749             inner: PhysicalDeviceScalarBlockLayoutFeatures::default(),
36750             marker: ::std::marker::PhantomData,
36751         }
36752     }
36753 }
36754 #[repr(transparent)]
36755 pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
36756     inner: PhysicalDeviceScalarBlockLayoutFeatures,
36757     marker: ::std::marker::PhantomData<&'a ()>,
36758 }
36759 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
36760 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {}
36761 impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
36762     type Target = PhysicalDeviceScalarBlockLayoutFeatures;
deref(&self) -> &Self::Target36763     fn deref(&self) -> &Self::Target {
36764         &self.inner
36765     }
36766 }
36767 impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36768     fn deref_mut(&mut self) -> &mut Self::Target {
36769         &mut self.inner
36770     }
36771 }
36772 impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
scalar_block_layout( mut self, scalar_block_layout: bool, ) -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a>36773     pub fn scalar_block_layout(
36774         mut self,
36775         scalar_block_layout: bool,
36776     ) -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
36777         self.inner.scalar_block_layout = scalar_block_layout.into();
36778         self
36779     }
36780     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36781     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36782     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceScalarBlockLayoutFeatures36783     pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures {
36784         self.inner
36785     }
36786 }
36787 #[repr(C)]
36788 #[derive(Copy, Clone, Debug)]
36789 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html>"]
36790 pub struct SurfaceProtectedCapabilitiesKHR {
36791     pub s_type: StructureType,
36792     pub p_next: *const c_void,
36793     pub supports_protected: Bool32,
36794 }
36795 impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR {
default() -> SurfaceProtectedCapabilitiesKHR36796     fn default() -> SurfaceProtectedCapabilitiesKHR {
36797         SurfaceProtectedCapabilitiesKHR {
36798             s_type: StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR,
36799             p_next: ::std::ptr::null(),
36800             supports_protected: Bool32::default(),
36801         }
36802     }
36803 }
36804 impl SurfaceProtectedCapabilitiesKHR {
builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a>36805     pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
36806         SurfaceProtectedCapabilitiesKHRBuilder {
36807             inner: SurfaceProtectedCapabilitiesKHR::default(),
36808             marker: ::std::marker::PhantomData,
36809         }
36810     }
36811 }
36812 #[repr(transparent)]
36813 pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> {
36814     inner: SurfaceProtectedCapabilitiesKHR,
36815     marker: ::std::marker::PhantomData<&'a ()>,
36816 }
36817 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {}
36818 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {}
36819 impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
36820     type Target = SurfaceProtectedCapabilitiesKHR;
deref(&self) -> &Self::Target36821     fn deref(&self) -> &Self::Target {
36822         &self.inner
36823     }
36824 }
36825 impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36826     fn deref_mut(&mut self) -> &mut Self::Target {
36827         &mut self.inner
36828     }
36829 }
36830 impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
supports_protected( mut self, supports_protected: bool, ) -> SurfaceProtectedCapabilitiesKHRBuilder<'a>36831     pub fn supports_protected(
36832         mut self,
36833         supports_protected: bool,
36834     ) -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
36835         self.inner.supports_protected = supports_protected.into();
36836         self
36837     }
36838     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36839     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36840     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceProtectedCapabilitiesKHR36841     pub fn build(self) -> SurfaceProtectedCapabilitiesKHR {
36842         self.inner
36843     }
36844 }
36845 #[repr(C)]
36846 #[derive(Copy, Clone, Debug)]
36847 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>"]
36848 pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
36849     pub s_type: StructureType,
36850     pub p_next: *mut c_void,
36851     pub uniform_buffer_standard_layout: Bool32,
36852 }
36853 impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures {
default() -> PhysicalDeviceUniformBufferStandardLayoutFeatures36854     fn default() -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
36855         PhysicalDeviceUniformBufferStandardLayoutFeatures {
36856             s_type: StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
36857             p_next: ::std::ptr::null_mut(),
36858             uniform_buffer_standard_layout: Bool32::default(),
36859         }
36860     }
36861 }
36862 impl PhysicalDeviceUniformBufferStandardLayoutFeatures {
builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a>36863     pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
36864         PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder {
36865             inner: PhysicalDeviceUniformBufferStandardLayoutFeatures::default(),
36866             marker: ::std::marker::PhantomData,
36867         }
36868     }
36869 }
36870 #[repr(transparent)]
36871 pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
36872     inner: PhysicalDeviceUniformBufferStandardLayoutFeatures,
36873     marker: ::std::marker::PhantomData<&'a ()>,
36874 }
36875 unsafe impl ExtendsDeviceCreateInfo
36876     for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
36877 {
36878 }
36879 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
36880 impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
36881     type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures;
deref(&self) -> &Self::Target36882     fn deref(&self) -> &Self::Target {
36883         &self.inner
36884     }
36885 }
36886 impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36887     fn deref_mut(&mut self) -> &mut Self::Target {
36888         &mut self.inner
36889     }
36890 }
36891 impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
uniform_buffer_standard_layout( mut self, uniform_buffer_standard_layout: bool, ) -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a>36892     pub fn uniform_buffer_standard_layout(
36893         mut self,
36894         uniform_buffer_standard_layout: bool,
36895     ) -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
36896         self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
36897         self
36898     }
36899     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36900     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36901     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures36902     pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
36903         self.inner
36904     }
36905 }
36906 #[repr(C)]
36907 #[derive(Copy, Clone, Debug)]
36908 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>"]
36909 pub struct PhysicalDeviceDepthClipEnableFeaturesEXT {
36910     pub s_type: StructureType,
36911     pub p_next: *mut c_void,
36912     pub depth_clip_enable: Bool32,
36913 }
36914 impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT {
default() -> PhysicalDeviceDepthClipEnableFeaturesEXT36915     fn default() -> PhysicalDeviceDepthClipEnableFeaturesEXT {
36916         PhysicalDeviceDepthClipEnableFeaturesEXT {
36917             s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
36918             p_next: ::std::ptr::null_mut(),
36919             depth_clip_enable: Bool32::default(),
36920         }
36921     }
36922 }
36923 impl PhysicalDeviceDepthClipEnableFeaturesEXT {
builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a>36924     pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
36925         PhysicalDeviceDepthClipEnableFeaturesEXTBuilder {
36926             inner: PhysicalDeviceDepthClipEnableFeaturesEXT::default(),
36927             marker: ::std::marker::PhantomData,
36928         }
36929     }
36930 }
36931 #[repr(transparent)]
36932 pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
36933     inner: PhysicalDeviceDepthClipEnableFeaturesEXT,
36934     marker: ::std::marker::PhantomData<&'a ()>,
36935 }
36936 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
36937 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {}
36938 impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
36939     type Target = PhysicalDeviceDepthClipEnableFeaturesEXT;
deref(&self) -> &Self::Target36940     fn deref(&self) -> &Self::Target {
36941         &self.inner
36942     }
36943 }
36944 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target36945     fn deref_mut(&mut self) -> &mut Self::Target {
36946         &mut self.inner
36947     }
36948 }
36949 impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
depth_clip_enable( mut self, depth_clip_enable: bool, ) -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a>36950     pub fn depth_clip_enable(
36951         mut self,
36952         depth_clip_enable: bool,
36953     ) -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
36954         self.inner.depth_clip_enable = depth_clip_enable.into();
36955         self
36956     }
36957     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
36958     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
36959     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT36960     pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT {
36961         self.inner
36962     }
36963 }
36964 #[repr(C)]
36965 #[derive(Copy, Clone, Debug)]
36966 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>"]
36967 pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
36968     pub s_type: StructureType,
36969     pub p_next: *const c_void,
36970     pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
36971     pub depth_clip_enable: Bool32,
36972 }
36973 impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT {
default() -> PipelineRasterizationDepthClipStateCreateInfoEXT36974     fn default() -> PipelineRasterizationDepthClipStateCreateInfoEXT {
36975         PipelineRasterizationDepthClipStateCreateInfoEXT {
36976             s_type: StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
36977             p_next: ::std::ptr::null(),
36978             flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(),
36979             depth_clip_enable: Bool32::default(),
36980         }
36981     }
36982 }
36983 impl PipelineRasterizationDepthClipStateCreateInfoEXT {
builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a>36984     pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
36985         PipelineRasterizationDepthClipStateCreateInfoEXTBuilder {
36986             inner: PipelineRasterizationDepthClipStateCreateInfoEXT::default(),
36987             marker: ::std::marker::PhantomData,
36988         }
36989     }
36990 }
36991 #[repr(transparent)]
36992 pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
36993     inner: PipelineRasterizationDepthClipStateCreateInfoEXT,
36994     marker: ::std::marker::PhantomData<&'a ()>,
36995 }
36996 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
36997     for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_>
36998 {
36999 }
37000 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
37001     for PipelineRasterizationDepthClipStateCreateInfoEXT
37002 {
37003 }
37004 impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
37005     type Target = PipelineRasterizationDepthClipStateCreateInfoEXT;
deref(&self) -> &Self::Target37006     fn deref(&self) -> &Self::Target {
37007         &self.inner
37008     }
37009 }
37010 impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37011     fn deref_mut(&mut self) -> &mut Self::Target {
37012         &mut self.inner
37013     }
37014 }
37015 impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
flags( mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT, ) -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a>37016     pub fn flags(
37017         mut self,
37018         flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
37019     ) -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
37020         self.inner.flags = flags;
37021         self
37022     }
depth_clip_enable( mut self, depth_clip_enable: bool, ) -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a>37023     pub fn depth_clip_enable(
37024         mut self,
37025         depth_clip_enable: bool,
37026     ) -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
37027         self.inner.depth_clip_enable = depth_clip_enable.into();
37028         self
37029     }
37030     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37031     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37032     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT37033     pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT {
37034         self.inner
37035     }
37036 }
37037 #[repr(C)]
37038 #[derive(Copy, Clone, Debug)]
37039 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>"]
37040 pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
37041     pub s_type: StructureType,
37042     pub p_next: *mut c_void,
37043     pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
37044     pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
37045 }
37046 impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT {
default() -> PhysicalDeviceMemoryBudgetPropertiesEXT37047     fn default() -> PhysicalDeviceMemoryBudgetPropertiesEXT {
37048         PhysicalDeviceMemoryBudgetPropertiesEXT {
37049             s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
37050             p_next: ::std::ptr::null_mut(),
37051             heap_budget: unsafe { ::std::mem::zeroed() },
37052             heap_usage: unsafe { ::std::mem::zeroed() },
37053         }
37054     }
37055 }
37056 impl PhysicalDeviceMemoryBudgetPropertiesEXT {
builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a>37057     pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
37058         PhysicalDeviceMemoryBudgetPropertiesEXTBuilder {
37059             inner: PhysicalDeviceMemoryBudgetPropertiesEXT::default(),
37060             marker: ::std::marker::PhantomData,
37061         }
37062     }
37063 }
37064 #[repr(transparent)]
37065 pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
37066     inner: PhysicalDeviceMemoryBudgetPropertiesEXT,
37067     marker: ::std::marker::PhantomData<&'a ()>,
37068 }
37069 unsafe impl ExtendsPhysicalDeviceMemoryProperties2
37070     for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_>
37071 {
37072 }
37073 unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {}
37074 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
37075     type Target = PhysicalDeviceMemoryBudgetPropertiesEXT;
deref(&self) -> &Self::Target37076     fn deref(&self) -> &Self::Target {
37077         &self.inner
37078     }
37079 }
37080 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37081     fn deref_mut(&mut self) -> &mut Self::Target {
37082         &mut self.inner
37083     }
37084 }
37085 impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
heap_budget( mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a>37086     pub fn heap_budget(
37087         mut self,
37088         heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
37089     ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
37090         self.inner.heap_budget = heap_budget;
37091         self
37092     }
heap_usage( mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a>37093     pub fn heap_usage(
37094         mut self,
37095         heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
37096     ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
37097         self.inner.heap_usage = heap_usage;
37098         self
37099     }
37100     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37101     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37102     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT37103     pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT {
37104         self.inner
37105     }
37106 }
37107 #[repr(C)]
37108 #[derive(Copy, Clone, Debug)]
37109 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>"]
37110 pub struct PhysicalDeviceMemoryPriorityFeaturesEXT {
37111     pub s_type: StructureType,
37112     pub p_next: *mut c_void,
37113     pub memory_priority: Bool32,
37114 }
37115 impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT {
default() -> PhysicalDeviceMemoryPriorityFeaturesEXT37116     fn default() -> PhysicalDeviceMemoryPriorityFeaturesEXT {
37117         PhysicalDeviceMemoryPriorityFeaturesEXT {
37118             s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
37119             p_next: ::std::ptr::null_mut(),
37120             memory_priority: Bool32::default(),
37121         }
37122     }
37123 }
37124 impl PhysicalDeviceMemoryPriorityFeaturesEXT {
builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a>37125     pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
37126         PhysicalDeviceMemoryPriorityFeaturesEXTBuilder {
37127             inner: PhysicalDeviceMemoryPriorityFeaturesEXT::default(),
37128             marker: ::std::marker::PhantomData,
37129         }
37130     }
37131 }
37132 #[repr(transparent)]
37133 pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
37134     inner: PhysicalDeviceMemoryPriorityFeaturesEXT,
37135     marker: ::std::marker::PhantomData<&'a ()>,
37136 }
37137 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
37138 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {}
37139 impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
37140     type Target = PhysicalDeviceMemoryPriorityFeaturesEXT;
deref(&self) -> &Self::Target37141     fn deref(&self) -> &Self::Target {
37142         &self.inner
37143     }
37144 }
37145 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37146     fn deref_mut(&mut self) -> &mut Self::Target {
37147         &mut self.inner
37148     }
37149 }
37150 impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
memory_priority( mut self, memory_priority: bool, ) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a>37151     pub fn memory_priority(
37152         mut self,
37153         memory_priority: bool,
37154     ) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
37155         self.inner.memory_priority = memory_priority.into();
37156         self
37157     }
37158     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37159     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37160     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT37161     pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT {
37162         self.inner
37163     }
37164 }
37165 #[repr(C)]
37166 #[derive(Copy, Clone, Debug)]
37167 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html>"]
37168 pub struct MemoryPriorityAllocateInfoEXT {
37169     pub s_type: StructureType,
37170     pub p_next: *const c_void,
37171     pub priority: f32,
37172 }
37173 impl ::std::default::Default for MemoryPriorityAllocateInfoEXT {
default() -> MemoryPriorityAllocateInfoEXT37174     fn default() -> MemoryPriorityAllocateInfoEXT {
37175         MemoryPriorityAllocateInfoEXT {
37176             s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
37177             p_next: ::std::ptr::null(),
37178             priority: f32::default(),
37179         }
37180     }
37181 }
37182 impl MemoryPriorityAllocateInfoEXT {
builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a>37183     pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
37184         MemoryPriorityAllocateInfoEXTBuilder {
37185             inner: MemoryPriorityAllocateInfoEXT::default(),
37186             marker: ::std::marker::PhantomData,
37187         }
37188     }
37189 }
37190 #[repr(transparent)]
37191 pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> {
37192     inner: MemoryPriorityAllocateInfoEXT,
37193     marker: ::std::marker::PhantomData<&'a ()>,
37194 }
37195 unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {}
37196 unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {}
37197 impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> {
37198     type Target = MemoryPriorityAllocateInfoEXT;
deref(&self) -> &Self::Target37199     fn deref(&self) -> &Self::Target {
37200         &self.inner
37201     }
37202 }
37203 impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37204     fn deref_mut(&mut self) -> &mut Self::Target {
37205         &mut self.inner
37206     }
37207 }
37208 impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
priority(mut self, priority: f32) -> MemoryPriorityAllocateInfoEXTBuilder<'a>37209     pub fn priority(mut self, priority: f32) -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
37210         self.inner.priority = priority;
37211         self
37212     }
37213     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37214     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37215     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryPriorityAllocateInfoEXT37216     pub fn build(self) -> MemoryPriorityAllocateInfoEXT {
37217         self.inner
37218     }
37219 }
37220 #[repr(C)]
37221 #[derive(Copy, Clone, Debug)]
37222 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>"]
37223 pub struct PhysicalDeviceBufferDeviceAddressFeatures {
37224     pub s_type: StructureType,
37225     pub p_next: *mut c_void,
37226     pub buffer_device_address: Bool32,
37227     pub buffer_device_address_capture_replay: Bool32,
37228     pub buffer_device_address_multi_device: Bool32,
37229 }
37230 impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures {
default() -> PhysicalDeviceBufferDeviceAddressFeatures37231     fn default() -> PhysicalDeviceBufferDeviceAddressFeatures {
37232         PhysicalDeviceBufferDeviceAddressFeatures {
37233             s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
37234             p_next: ::std::ptr::null_mut(),
37235             buffer_device_address: Bool32::default(),
37236             buffer_device_address_capture_replay: Bool32::default(),
37237             buffer_device_address_multi_device: Bool32::default(),
37238         }
37239     }
37240 }
37241 impl PhysicalDeviceBufferDeviceAddressFeatures {
builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a>37242     pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
37243         PhysicalDeviceBufferDeviceAddressFeaturesBuilder {
37244             inner: PhysicalDeviceBufferDeviceAddressFeatures::default(),
37245             marker: ::std::marker::PhantomData,
37246         }
37247     }
37248 }
37249 #[repr(transparent)]
37250 pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
37251     inner: PhysicalDeviceBufferDeviceAddressFeatures,
37252     marker: ::std::marker::PhantomData<&'a ()>,
37253 }
37254 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {}
37255 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {}
37256 impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
37257     type Target = PhysicalDeviceBufferDeviceAddressFeatures;
deref(&self) -> &Self::Target37258     fn deref(&self) -> &Self::Target {
37259         &self.inner
37260     }
37261 }
37262 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37263     fn deref_mut(&mut self) -> &mut Self::Target {
37264         &mut self.inner
37265     }
37266 }
37267 impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
buffer_device_address( mut self, buffer_device_address: bool, ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a>37268     pub fn buffer_device_address(
37269         mut self,
37270         buffer_device_address: bool,
37271     ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
37272         self.inner.buffer_device_address = buffer_device_address.into();
37273         self
37274     }
buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a>37275     pub fn buffer_device_address_capture_replay(
37276         mut self,
37277         buffer_device_address_capture_replay: bool,
37278     ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
37279         self.inner.buffer_device_address_capture_replay =
37280             buffer_device_address_capture_replay.into();
37281         self
37282     }
buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a>37283     pub fn buffer_device_address_multi_device(
37284         mut self,
37285         buffer_device_address_multi_device: bool,
37286     ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
37287         self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
37288         self
37289     }
37290     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37291     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37292     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBufferDeviceAddressFeatures37293     pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures {
37294         self.inner
37295     }
37296 }
37297 #[repr(C)]
37298 #[derive(Copy, Clone, Debug)]
37299 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>"]
37300 pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
37301     pub s_type: StructureType,
37302     pub p_next: *mut c_void,
37303     pub buffer_device_address: Bool32,
37304     pub buffer_device_address_capture_replay: Bool32,
37305     pub buffer_device_address_multi_device: Bool32,
37306 }
37307 impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
default() -> PhysicalDeviceBufferDeviceAddressFeaturesEXT37308     fn default() -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
37309         PhysicalDeviceBufferDeviceAddressFeaturesEXT {
37310             s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
37311             p_next: ::std::ptr::null_mut(),
37312             buffer_device_address: Bool32::default(),
37313             buffer_device_address_capture_replay: Bool32::default(),
37314             buffer_device_address_multi_device: Bool32::default(),
37315         }
37316     }
37317 }
37318 impl PhysicalDeviceBufferDeviceAddressFeaturesEXT {
builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a>37319     pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
37320         PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder {
37321             inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT::default(),
37322             marker: ::std::marker::PhantomData,
37323         }
37324     }
37325 }
37326 #[repr(transparent)]
37327 pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
37328     inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT,
37329     marker: ::std::marker::PhantomData<&'a ()>,
37330 }
37331 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {}
37332 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
37333 impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
37334     type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
deref(&self) -> &Self::Target37335     fn deref(&self) -> &Self::Target {
37336         &self.inner
37337     }
37338 }
37339 impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37340     fn deref_mut(&mut self) -> &mut Self::Target {
37341         &mut self.inner
37342     }
37343 }
37344 impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
buffer_device_address( mut self, buffer_device_address: bool, ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a>37345     pub fn buffer_device_address(
37346         mut self,
37347         buffer_device_address: bool,
37348     ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
37349         self.inner.buffer_device_address = buffer_device_address.into();
37350         self
37351     }
buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a>37352     pub fn buffer_device_address_capture_replay(
37353         mut self,
37354         buffer_device_address_capture_replay: bool,
37355     ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
37356         self.inner.buffer_device_address_capture_replay =
37357             buffer_device_address_capture_replay.into();
37358         self
37359     }
buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a>37360     pub fn buffer_device_address_multi_device(
37361         mut self,
37362         buffer_device_address_multi_device: bool,
37363     ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
37364         self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
37365         self
37366     }
37367     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37368     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37369     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT37370     pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
37371         self.inner
37372     }
37373 }
37374 #[repr(C)]
37375 #[derive(Copy, Clone, Debug)]
37376 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferDeviceAddressInfo.html>"]
37377 pub struct BufferDeviceAddressInfo {
37378     pub s_type: StructureType,
37379     pub p_next: *const c_void,
37380     pub buffer: Buffer,
37381 }
37382 impl ::std::default::Default for BufferDeviceAddressInfo {
default() -> BufferDeviceAddressInfo37383     fn default() -> BufferDeviceAddressInfo {
37384         BufferDeviceAddressInfo {
37385             s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO,
37386             p_next: ::std::ptr::null(),
37387             buffer: Buffer::default(),
37388         }
37389     }
37390 }
37391 impl BufferDeviceAddressInfo {
builder<'a>() -> BufferDeviceAddressInfoBuilder<'a>37392     pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> {
37393         BufferDeviceAddressInfoBuilder {
37394             inner: BufferDeviceAddressInfo::default(),
37395             marker: ::std::marker::PhantomData,
37396         }
37397     }
37398 }
37399 #[repr(transparent)]
37400 pub struct BufferDeviceAddressInfoBuilder<'a> {
37401     inner: BufferDeviceAddressInfo,
37402     marker: ::std::marker::PhantomData<&'a ()>,
37403 }
37404 pub unsafe trait ExtendsBufferDeviceAddressInfo {}
37405 impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> {
37406     type Target = BufferDeviceAddressInfo;
deref(&self) -> &Self::Target37407     fn deref(&self) -> &Self::Target {
37408         &self.inner
37409     }
37410 }
37411 impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37412     fn deref_mut(&mut self) -> &mut Self::Target {
37413         &mut self.inner
37414     }
37415 }
37416 impl<'a> BufferDeviceAddressInfoBuilder<'a> {
buffer(mut self, buffer: Buffer) -> BufferDeviceAddressInfoBuilder<'a>37417     pub fn buffer(mut self, buffer: Buffer) -> BufferDeviceAddressInfoBuilder<'a> {
37418         self.inner.buffer = buffer;
37419         self
37420     }
37421     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
37422     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
37423     #[doc = r" valid extension structs can be pushed into the chain."]
37424     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
37425     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferDeviceAddressInfo>( mut self, next: &'a mut T, ) -> BufferDeviceAddressInfoBuilder<'a>37426     pub fn push_next<T: ExtendsBufferDeviceAddressInfo>(
37427         mut self,
37428         next: &'a mut T,
37429     ) -> BufferDeviceAddressInfoBuilder<'a> {
37430         unsafe {
37431             let next_ptr = next as *mut T as *mut BaseOutStructure;
37432             let last_next = ptr_chain_iter(next).last().unwrap();
37433             (*last_next).p_next = self.inner.p_next as _;
37434             self.inner.p_next = next_ptr as _;
37435         }
37436         self
37437     }
37438     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37439     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37440     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferDeviceAddressInfo37441     pub fn build(self) -> BufferDeviceAddressInfo {
37442         self.inner
37443     }
37444 }
37445 #[repr(C)]
37446 #[derive(Copy, Clone, Debug)]
37447 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>"]
37448 pub struct BufferOpaqueCaptureAddressCreateInfo {
37449     pub s_type: StructureType,
37450     pub p_next: *const c_void,
37451     pub opaque_capture_address: u64,
37452 }
37453 impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo {
default() -> BufferOpaqueCaptureAddressCreateInfo37454     fn default() -> BufferOpaqueCaptureAddressCreateInfo {
37455         BufferOpaqueCaptureAddressCreateInfo {
37456             s_type: StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
37457             p_next: ::std::ptr::null(),
37458             opaque_capture_address: u64::default(),
37459         }
37460     }
37461 }
37462 impl BufferOpaqueCaptureAddressCreateInfo {
builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a>37463     pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
37464         BufferOpaqueCaptureAddressCreateInfoBuilder {
37465             inner: BufferOpaqueCaptureAddressCreateInfo::default(),
37466             marker: ::std::marker::PhantomData,
37467         }
37468     }
37469 }
37470 #[repr(transparent)]
37471 pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
37472     inner: BufferOpaqueCaptureAddressCreateInfo,
37473     marker: ::std::marker::PhantomData<&'a ()>,
37474 }
37475 unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {}
37476 unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {}
37477 impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
37478     type Target = BufferOpaqueCaptureAddressCreateInfo;
deref(&self) -> &Self::Target37479     fn deref(&self) -> &Self::Target {
37480         &self.inner
37481     }
37482 }
37483 impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37484     fn deref_mut(&mut self) -> &mut Self::Target {
37485         &mut self.inner
37486     }
37487 }
37488 impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
opaque_capture_address( mut self, opaque_capture_address: u64, ) -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a>37489     pub fn opaque_capture_address(
37490         mut self,
37491         opaque_capture_address: u64,
37492     ) -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
37493         self.inner.opaque_capture_address = opaque_capture_address;
37494         self
37495     }
37496     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37497     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37498     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferOpaqueCaptureAddressCreateInfo37499     pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo {
37500         self.inner
37501     }
37502 }
37503 #[repr(C)]
37504 #[derive(Copy, Clone, Debug)]
37505 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html>"]
37506 pub struct BufferDeviceAddressCreateInfoEXT {
37507     pub s_type: StructureType,
37508     pub p_next: *const c_void,
37509     pub device_address: DeviceAddress,
37510 }
37511 impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT {
default() -> BufferDeviceAddressCreateInfoEXT37512     fn default() -> BufferDeviceAddressCreateInfoEXT {
37513         BufferDeviceAddressCreateInfoEXT {
37514             s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
37515             p_next: ::std::ptr::null(),
37516             device_address: DeviceAddress::default(),
37517         }
37518     }
37519 }
37520 impl BufferDeviceAddressCreateInfoEXT {
builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a>37521     pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
37522         BufferDeviceAddressCreateInfoEXTBuilder {
37523             inner: BufferDeviceAddressCreateInfoEXT::default(),
37524             marker: ::std::marker::PhantomData,
37525         }
37526     }
37527 }
37528 #[repr(transparent)]
37529 pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> {
37530     inner: BufferDeviceAddressCreateInfoEXT,
37531     marker: ::std::marker::PhantomData<&'a ()>,
37532 }
37533 unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {}
37534 unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {}
37535 impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
37536     type Target = BufferDeviceAddressCreateInfoEXT;
deref(&self) -> &Self::Target37537     fn deref(&self) -> &Self::Target {
37538         &self.inner
37539     }
37540 }
37541 impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37542     fn deref_mut(&mut self) -> &mut Self::Target {
37543         &mut self.inner
37544     }
37545 }
37546 impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
device_address( mut self, device_address: DeviceAddress, ) -> BufferDeviceAddressCreateInfoEXTBuilder<'a>37547     pub fn device_address(
37548         mut self,
37549         device_address: DeviceAddress,
37550     ) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
37551         self.inner.device_address = device_address;
37552         self
37553     }
37554     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37555     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37556     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferDeviceAddressCreateInfoEXT37557     pub fn build(self) -> BufferDeviceAddressCreateInfoEXT {
37558         self.inner
37559     }
37560 }
37561 #[repr(C)]
37562 #[derive(Copy, Clone, Debug)]
37563 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>"]
37564 pub struct PhysicalDeviceImageViewImageFormatInfoEXT {
37565     pub s_type: StructureType,
37566     pub p_next: *mut c_void,
37567     pub image_view_type: ImageViewType,
37568 }
37569 impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT {
default() -> PhysicalDeviceImageViewImageFormatInfoEXT37570     fn default() -> PhysicalDeviceImageViewImageFormatInfoEXT {
37571         PhysicalDeviceImageViewImageFormatInfoEXT {
37572             s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
37573             p_next: ::std::ptr::null_mut(),
37574             image_view_type: ImageViewType::default(),
37575         }
37576     }
37577 }
37578 impl PhysicalDeviceImageViewImageFormatInfoEXT {
builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a>37579     pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
37580         PhysicalDeviceImageViewImageFormatInfoEXTBuilder {
37581             inner: PhysicalDeviceImageViewImageFormatInfoEXT::default(),
37582             marker: ::std::marker::PhantomData,
37583         }
37584     }
37585 }
37586 #[repr(transparent)]
37587 pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
37588     inner: PhysicalDeviceImageViewImageFormatInfoEXT,
37589     marker: ::std::marker::PhantomData<&'a ()>,
37590 }
37591 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
37592     for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_>
37593 {
37594 }
37595 unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {}
37596 impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
37597     type Target = PhysicalDeviceImageViewImageFormatInfoEXT;
deref(&self) -> &Self::Target37598     fn deref(&self) -> &Self::Target {
37599         &self.inner
37600     }
37601 }
37602 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37603     fn deref_mut(&mut self) -> &mut Self::Target {
37604         &mut self.inner
37605     }
37606 }
37607 impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
image_view_type( mut self, image_view_type: ImageViewType, ) -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a>37608     pub fn image_view_type(
37609         mut self,
37610         image_view_type: ImageViewType,
37611     ) -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
37612         self.inner.image_view_type = image_view_type;
37613         self
37614     }
37615     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37616     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37617     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT37618     pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT {
37619         self.inner
37620     }
37621 }
37622 #[repr(C)]
37623 #[derive(Copy, Clone, Debug)]
37624 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>"]
37625 pub struct FilterCubicImageViewImageFormatPropertiesEXT {
37626     pub s_type: StructureType,
37627     pub p_next: *mut c_void,
37628     pub filter_cubic: Bool32,
37629     pub filter_cubic_minmax: Bool32,
37630 }
37631 impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT {
default() -> FilterCubicImageViewImageFormatPropertiesEXT37632     fn default() -> FilterCubicImageViewImageFormatPropertiesEXT {
37633         FilterCubicImageViewImageFormatPropertiesEXT {
37634             s_type: StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
37635             p_next: ::std::ptr::null_mut(),
37636             filter_cubic: Bool32::default(),
37637             filter_cubic_minmax: Bool32::default(),
37638         }
37639     }
37640 }
37641 impl FilterCubicImageViewImageFormatPropertiesEXT {
builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a>37642     pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
37643         FilterCubicImageViewImageFormatPropertiesEXTBuilder {
37644             inner: FilterCubicImageViewImageFormatPropertiesEXT::default(),
37645             marker: ::std::marker::PhantomData,
37646         }
37647     }
37648 }
37649 #[repr(transparent)]
37650 pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
37651     inner: FilterCubicImageViewImageFormatPropertiesEXT,
37652     marker: ::std::marker::PhantomData<&'a ()>,
37653 }
37654 unsafe impl ExtendsImageFormatProperties2
37655     for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_>
37656 {
37657 }
37658 unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {}
37659 impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
37660     type Target = FilterCubicImageViewImageFormatPropertiesEXT;
deref(&self) -> &Self::Target37661     fn deref(&self) -> &Self::Target {
37662         &self.inner
37663     }
37664 }
37665 impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37666     fn deref_mut(&mut self) -> &mut Self::Target {
37667         &mut self.inner
37668     }
37669 }
37670 impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
filter_cubic( mut self, filter_cubic: bool, ) -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a>37671     pub fn filter_cubic(
37672         mut self,
37673         filter_cubic: bool,
37674     ) -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
37675         self.inner.filter_cubic = filter_cubic.into();
37676         self
37677     }
filter_cubic_minmax( mut self, filter_cubic_minmax: bool, ) -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a>37678     pub fn filter_cubic_minmax(
37679         mut self,
37680         filter_cubic_minmax: bool,
37681     ) -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
37682         self.inner.filter_cubic_minmax = filter_cubic_minmax.into();
37683         self
37684     }
37685     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37686     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37687     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FilterCubicImageViewImageFormatPropertiesEXT37688     pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT {
37689         self.inner
37690     }
37691 }
37692 #[repr(C)]
37693 #[derive(Copy, Clone, Debug)]
37694 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>"]
37695 pub struct PhysicalDeviceImagelessFramebufferFeatures {
37696     pub s_type: StructureType,
37697     pub p_next: *mut c_void,
37698     pub imageless_framebuffer: Bool32,
37699 }
37700 impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures {
default() -> PhysicalDeviceImagelessFramebufferFeatures37701     fn default() -> PhysicalDeviceImagelessFramebufferFeatures {
37702         PhysicalDeviceImagelessFramebufferFeatures {
37703             s_type: StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
37704             p_next: ::std::ptr::null_mut(),
37705             imageless_framebuffer: Bool32::default(),
37706         }
37707     }
37708 }
37709 impl PhysicalDeviceImagelessFramebufferFeatures {
builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a>37710     pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
37711         PhysicalDeviceImagelessFramebufferFeaturesBuilder {
37712             inner: PhysicalDeviceImagelessFramebufferFeatures::default(),
37713             marker: ::std::marker::PhantomData,
37714         }
37715     }
37716 }
37717 #[repr(transparent)]
37718 pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
37719     inner: PhysicalDeviceImagelessFramebufferFeatures,
37720     marker: ::std::marker::PhantomData<&'a ()>,
37721 }
37722 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {}
37723 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {}
37724 impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
37725     type Target = PhysicalDeviceImagelessFramebufferFeatures;
deref(&self) -> &Self::Target37726     fn deref(&self) -> &Self::Target {
37727         &self.inner
37728     }
37729 }
37730 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37731     fn deref_mut(&mut self) -> &mut Self::Target {
37732         &mut self.inner
37733     }
37734 }
37735 impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
imageless_framebuffer( mut self, imageless_framebuffer: bool, ) -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a>37736     pub fn imageless_framebuffer(
37737         mut self,
37738         imageless_framebuffer: bool,
37739     ) -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
37740         self.inner.imageless_framebuffer = imageless_framebuffer.into();
37741         self
37742     }
37743     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37744     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37745     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImagelessFramebufferFeatures37746     pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures {
37747         self.inner
37748     }
37749 }
37750 #[repr(C)]
37751 #[derive(Copy, Clone, Debug)]
37752 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html>"]
37753 pub struct FramebufferAttachmentsCreateInfo {
37754     pub s_type: StructureType,
37755     pub p_next: *const c_void,
37756     pub attachment_image_info_count: u32,
37757     pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo,
37758 }
37759 impl ::std::default::Default for FramebufferAttachmentsCreateInfo {
default() -> FramebufferAttachmentsCreateInfo37760     fn default() -> FramebufferAttachmentsCreateInfo {
37761         FramebufferAttachmentsCreateInfo {
37762             s_type: StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
37763             p_next: ::std::ptr::null(),
37764             attachment_image_info_count: u32::default(),
37765             p_attachment_image_infos: ::std::ptr::null(),
37766         }
37767     }
37768 }
37769 impl FramebufferAttachmentsCreateInfo {
builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a>37770     pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> {
37771         FramebufferAttachmentsCreateInfoBuilder {
37772             inner: FramebufferAttachmentsCreateInfo::default(),
37773             marker: ::std::marker::PhantomData,
37774         }
37775     }
37776 }
37777 #[repr(transparent)]
37778 pub struct FramebufferAttachmentsCreateInfoBuilder<'a> {
37779     inner: FramebufferAttachmentsCreateInfo,
37780     marker: ::std::marker::PhantomData<&'a ()>,
37781 }
37782 unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {}
37783 unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {}
37784 impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> {
37785     type Target = FramebufferAttachmentsCreateInfo;
deref(&self) -> &Self::Target37786     fn deref(&self) -> &Self::Target {
37787         &self.inner
37788     }
37789 }
37790 impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37791     fn deref_mut(&mut self) -> &mut Self::Target {
37792         &mut self.inner
37793     }
37794 }
37795 impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
attachment_image_infos( mut self, attachment_image_infos: &'a [FramebufferAttachmentImageInfo], ) -> FramebufferAttachmentsCreateInfoBuilder<'a>37796     pub fn attachment_image_infos(
37797         mut self,
37798         attachment_image_infos: &'a [FramebufferAttachmentImageInfo],
37799     ) -> FramebufferAttachmentsCreateInfoBuilder<'a> {
37800         self.inner.attachment_image_info_count = attachment_image_infos.len() as _;
37801         self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr();
37802         self
37803     }
37804     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37805     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37806     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferAttachmentsCreateInfo37807     pub fn build(self) -> FramebufferAttachmentsCreateInfo {
37808         self.inner
37809     }
37810 }
37811 #[repr(C)]
37812 #[derive(Copy, Clone, Debug)]
37813 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferAttachmentImageInfo.html>"]
37814 pub struct FramebufferAttachmentImageInfo {
37815     pub s_type: StructureType,
37816     pub p_next: *const c_void,
37817     pub flags: ImageCreateFlags,
37818     pub usage: ImageUsageFlags,
37819     pub width: u32,
37820     pub height: u32,
37821     pub layer_count: u32,
37822     pub view_format_count: u32,
37823     pub p_view_formats: *const Format,
37824 }
37825 impl ::std::default::Default for FramebufferAttachmentImageInfo {
default() -> FramebufferAttachmentImageInfo37826     fn default() -> FramebufferAttachmentImageInfo {
37827         FramebufferAttachmentImageInfo {
37828             s_type: StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
37829             p_next: ::std::ptr::null(),
37830             flags: ImageCreateFlags::default(),
37831             usage: ImageUsageFlags::default(),
37832             width: u32::default(),
37833             height: u32::default(),
37834             layer_count: u32::default(),
37835             view_format_count: u32::default(),
37836             p_view_formats: ::std::ptr::null(),
37837         }
37838     }
37839 }
37840 impl FramebufferAttachmentImageInfo {
builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a>37841     pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> {
37842         FramebufferAttachmentImageInfoBuilder {
37843             inner: FramebufferAttachmentImageInfo::default(),
37844             marker: ::std::marker::PhantomData,
37845         }
37846     }
37847 }
37848 #[repr(transparent)]
37849 pub struct FramebufferAttachmentImageInfoBuilder<'a> {
37850     inner: FramebufferAttachmentImageInfo,
37851     marker: ::std::marker::PhantomData<&'a ()>,
37852 }
37853 pub unsafe trait ExtendsFramebufferAttachmentImageInfo {}
37854 impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> {
37855     type Target = FramebufferAttachmentImageInfo;
deref(&self) -> &Self::Target37856     fn deref(&self) -> &Self::Target {
37857         &self.inner
37858     }
37859 }
37860 impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37861     fn deref_mut(&mut self) -> &mut Self::Target {
37862         &mut self.inner
37863     }
37864 }
37865 impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
flags(mut self, flags: ImageCreateFlags) -> FramebufferAttachmentImageInfoBuilder<'a>37866     pub fn flags(mut self, flags: ImageCreateFlags) -> FramebufferAttachmentImageInfoBuilder<'a> {
37867         self.inner.flags = flags;
37868         self
37869     }
usage(mut self, usage: ImageUsageFlags) -> FramebufferAttachmentImageInfoBuilder<'a>37870     pub fn usage(mut self, usage: ImageUsageFlags) -> FramebufferAttachmentImageInfoBuilder<'a> {
37871         self.inner.usage = usage;
37872         self
37873     }
width(mut self, width: u32) -> FramebufferAttachmentImageInfoBuilder<'a>37874     pub fn width(mut self, width: u32) -> FramebufferAttachmentImageInfoBuilder<'a> {
37875         self.inner.width = width;
37876         self
37877     }
height(mut self, height: u32) -> FramebufferAttachmentImageInfoBuilder<'a>37878     pub fn height(mut self, height: u32) -> FramebufferAttachmentImageInfoBuilder<'a> {
37879         self.inner.height = height;
37880         self
37881     }
layer_count(mut self, layer_count: u32) -> FramebufferAttachmentImageInfoBuilder<'a>37882     pub fn layer_count(mut self, layer_count: u32) -> FramebufferAttachmentImageInfoBuilder<'a> {
37883         self.inner.layer_count = layer_count;
37884         self
37885     }
view_formats( mut self, view_formats: &'a [Format], ) -> FramebufferAttachmentImageInfoBuilder<'a>37886     pub fn view_formats(
37887         mut self,
37888         view_formats: &'a [Format],
37889     ) -> FramebufferAttachmentImageInfoBuilder<'a> {
37890         self.inner.view_format_count = view_formats.len() as _;
37891         self.inner.p_view_formats = view_formats.as_ptr();
37892         self
37893     }
37894     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
37895     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
37896     #[doc = r" valid extension structs can be pushed into the chain."]
37897     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
37898     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFramebufferAttachmentImageInfo>( mut self, next: &'a mut T, ) -> FramebufferAttachmentImageInfoBuilder<'a>37899     pub fn push_next<T: ExtendsFramebufferAttachmentImageInfo>(
37900         mut self,
37901         next: &'a mut T,
37902     ) -> FramebufferAttachmentImageInfoBuilder<'a> {
37903         unsafe {
37904             let next_ptr = next as *mut T as *mut BaseOutStructure;
37905             let last_next = ptr_chain_iter(next).last().unwrap();
37906             (*last_next).p_next = self.inner.p_next as _;
37907             self.inner.p_next = next_ptr as _;
37908         }
37909         self
37910     }
37911     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37912     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37913     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferAttachmentImageInfo37914     pub fn build(self) -> FramebufferAttachmentImageInfo {
37915         self.inner
37916     }
37917 }
37918 #[repr(C)]
37919 #[derive(Copy, Clone, Debug)]
37920 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassAttachmentBeginInfo.html>"]
37921 pub struct RenderPassAttachmentBeginInfo {
37922     pub s_type: StructureType,
37923     pub p_next: *const c_void,
37924     pub attachment_count: u32,
37925     pub p_attachments: *const ImageView,
37926 }
37927 impl ::std::default::Default for RenderPassAttachmentBeginInfo {
default() -> RenderPassAttachmentBeginInfo37928     fn default() -> RenderPassAttachmentBeginInfo {
37929         RenderPassAttachmentBeginInfo {
37930             s_type: StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO,
37931             p_next: ::std::ptr::null(),
37932             attachment_count: u32::default(),
37933             p_attachments: ::std::ptr::null(),
37934         }
37935     }
37936 }
37937 impl RenderPassAttachmentBeginInfo {
builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a>37938     pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> {
37939         RenderPassAttachmentBeginInfoBuilder {
37940             inner: RenderPassAttachmentBeginInfo::default(),
37941             marker: ::std::marker::PhantomData,
37942         }
37943     }
37944 }
37945 #[repr(transparent)]
37946 pub struct RenderPassAttachmentBeginInfoBuilder<'a> {
37947     inner: RenderPassAttachmentBeginInfo,
37948     marker: ::std::marker::PhantomData<&'a ()>,
37949 }
37950 unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {}
37951 unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {}
37952 impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> {
37953     type Target = RenderPassAttachmentBeginInfo;
deref(&self) -> &Self::Target37954     fn deref(&self) -> &Self::Target {
37955         &self.inner
37956     }
37957 }
37958 impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target37959     fn deref_mut(&mut self) -> &mut Self::Target {
37960         &mut self.inner
37961     }
37962 }
37963 impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
attachments( mut self, attachments: &'a [ImageView], ) -> RenderPassAttachmentBeginInfoBuilder<'a>37964     pub fn attachments(
37965         mut self,
37966         attachments: &'a [ImageView],
37967     ) -> RenderPassAttachmentBeginInfoBuilder<'a> {
37968         self.inner.attachment_count = attachments.len() as _;
37969         self.inner.p_attachments = attachments.as_ptr();
37970         self
37971     }
37972     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
37973     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
37974     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassAttachmentBeginInfo37975     pub fn build(self) -> RenderPassAttachmentBeginInfo {
37976         self.inner
37977     }
37978 }
37979 #[repr(C)]
37980 #[derive(Copy, Clone, Debug)]
37981 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT.html>"]
37982 pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
37983     pub s_type: StructureType,
37984     pub p_next: *mut c_void,
37985     pub texture_compression_astc_hdr: Bool32,
37986 }
37987 impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
default() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT37988     fn default() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
37989         PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
37990             s_type: StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT,
37991             p_next: ::std::ptr::null_mut(),
37992             texture_compression_astc_hdr: Bool32::default(),
37993         }
37994     }
37995 }
37996 impl PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a>37997     pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
37998         PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder {
37999             inner: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::default(),
38000             marker: ::std::marker::PhantomData,
38001         }
38002     }
38003 }
38004 #[repr(transparent)]
38005 pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
38006     inner: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT,
38007     marker: ::std::marker::PhantomData<&'a ()>,
38008 }
38009 unsafe impl ExtendsDeviceCreateInfo
38010     for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'_>
38011 {
38012 }
38013 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {}
38014 impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
38015     type Target = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
deref(&self) -> &Self::Target38016     fn deref(&self) -> &Self::Target {
38017         &self.inner
38018     }
38019 }
38020 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38021     fn deref_mut(&mut self) -> &mut Self::Target {
38022         &mut self.inner
38023     }
38024 }
38025 impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
texture_compression_astc_hdr( mut self, texture_compression_astc_hdr: bool, ) -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a>38026     pub fn texture_compression_astc_hdr(
38027         mut self,
38028         texture_compression_astc_hdr: bool,
38029     ) -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
38030         self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
38031         self
38032     }
38033     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38034     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38035     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT38036     pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
38037         self.inner
38038     }
38039 }
38040 #[repr(C)]
38041 #[derive(Copy, Clone, Debug)]
38042 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>"]
38043 pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
38044     pub s_type: StructureType,
38045     pub p_next: *mut c_void,
38046     pub cooperative_matrix: Bool32,
38047     pub cooperative_matrix_robust_buffer_access: Bool32,
38048 }
38049 impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV {
default() -> PhysicalDeviceCooperativeMatrixFeaturesNV38050     fn default() -> PhysicalDeviceCooperativeMatrixFeaturesNV {
38051         PhysicalDeviceCooperativeMatrixFeaturesNV {
38052             s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
38053             p_next: ::std::ptr::null_mut(),
38054             cooperative_matrix: Bool32::default(),
38055             cooperative_matrix_robust_buffer_access: Bool32::default(),
38056         }
38057     }
38058 }
38059 impl PhysicalDeviceCooperativeMatrixFeaturesNV {
builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a>38060     pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
38061         PhysicalDeviceCooperativeMatrixFeaturesNVBuilder {
38062             inner: PhysicalDeviceCooperativeMatrixFeaturesNV::default(),
38063             marker: ::std::marker::PhantomData,
38064         }
38065     }
38066 }
38067 #[repr(transparent)]
38068 pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
38069     inner: PhysicalDeviceCooperativeMatrixFeaturesNV,
38070     marker: ::std::marker::PhantomData<&'a ()>,
38071 }
38072 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {}
38073 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {}
38074 impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
38075     type Target = PhysicalDeviceCooperativeMatrixFeaturesNV;
deref(&self) -> &Self::Target38076     fn deref(&self) -> &Self::Target {
38077         &self.inner
38078     }
38079 }
38080 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38081     fn deref_mut(&mut self) -> &mut Self::Target {
38082         &mut self.inner
38083     }
38084 }
38085 impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
cooperative_matrix( mut self, cooperative_matrix: bool, ) -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a>38086     pub fn cooperative_matrix(
38087         mut self,
38088         cooperative_matrix: bool,
38089     ) -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
38090         self.inner.cooperative_matrix = cooperative_matrix.into();
38091         self
38092     }
cooperative_matrix_robust_buffer_access( mut self, cooperative_matrix_robust_buffer_access: bool, ) -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a>38093     pub fn cooperative_matrix_robust_buffer_access(
38094         mut self,
38095         cooperative_matrix_robust_buffer_access: bool,
38096     ) -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
38097         self.inner.cooperative_matrix_robust_buffer_access =
38098             cooperative_matrix_robust_buffer_access.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."]
build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV38104     pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV {
38105         self.inner
38106     }
38107 }
38108 #[repr(C)]
38109 #[derive(Copy, Clone, Debug)]
38110 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
38111 pub struct PhysicalDeviceCooperativeMatrixPropertiesNV {
38112     pub s_type: StructureType,
38113     pub p_next: *mut c_void,
38114     pub cooperative_matrix_supported_stages: ShaderStageFlags,
38115 }
38116 impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV {
default() -> PhysicalDeviceCooperativeMatrixPropertiesNV38117     fn default() -> PhysicalDeviceCooperativeMatrixPropertiesNV {
38118         PhysicalDeviceCooperativeMatrixPropertiesNV {
38119             s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
38120             p_next: ::std::ptr::null_mut(),
38121             cooperative_matrix_supported_stages: ShaderStageFlags::default(),
38122         }
38123     }
38124 }
38125 impl PhysicalDeviceCooperativeMatrixPropertiesNV {
builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a>38126     pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
38127         PhysicalDeviceCooperativeMatrixPropertiesNVBuilder {
38128             inner: PhysicalDeviceCooperativeMatrixPropertiesNV::default(),
38129             marker: ::std::marker::PhantomData,
38130         }
38131     }
38132 }
38133 #[repr(transparent)]
38134 pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
38135     inner: PhysicalDeviceCooperativeMatrixPropertiesNV,
38136     marker: ::std::marker::PhantomData<&'a ()>,
38137 }
38138 unsafe impl ExtendsPhysicalDeviceProperties2
38139     for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_>
38140 {
38141 }
38142 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {}
38143 impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
38144     type Target = PhysicalDeviceCooperativeMatrixPropertiesNV;
deref(&self) -> &Self::Target38145     fn deref(&self) -> &Self::Target {
38146         &self.inner
38147     }
38148 }
38149 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38150     fn deref_mut(&mut self) -> &mut Self::Target {
38151         &mut self.inner
38152     }
38153 }
38154 impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
cooperative_matrix_supported_stages( mut self, cooperative_matrix_supported_stages: ShaderStageFlags, ) -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a>38155     pub fn cooperative_matrix_supported_stages(
38156         mut self,
38157         cooperative_matrix_supported_stages: ShaderStageFlags,
38158     ) -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
38159         self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages;
38160         self
38161     }
38162     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38163     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38164     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV38165     pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV {
38166         self.inner
38167     }
38168 }
38169 #[repr(C)]
38170 #[derive(Copy, Clone, Debug)]
38171 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCooperativeMatrixPropertiesNV.html>"]
38172 pub struct CooperativeMatrixPropertiesNV {
38173     pub s_type: StructureType,
38174     pub p_next: *mut c_void,
38175     pub m_size: u32,
38176     pub n_size: u32,
38177     pub k_size: u32,
38178     pub a_type: ComponentTypeNV,
38179     pub b_type: ComponentTypeNV,
38180     pub c_type: ComponentTypeNV,
38181     pub d_type: ComponentTypeNV,
38182     pub scope: ScopeNV,
38183 }
38184 impl ::std::default::Default for CooperativeMatrixPropertiesNV {
default() -> CooperativeMatrixPropertiesNV38185     fn default() -> CooperativeMatrixPropertiesNV {
38186         CooperativeMatrixPropertiesNV {
38187             s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV,
38188             p_next: ::std::ptr::null_mut(),
38189             m_size: u32::default(),
38190             n_size: u32::default(),
38191             k_size: u32::default(),
38192             a_type: ComponentTypeNV::default(),
38193             b_type: ComponentTypeNV::default(),
38194             c_type: ComponentTypeNV::default(),
38195             d_type: ComponentTypeNV::default(),
38196             scope: ScopeNV::default(),
38197         }
38198     }
38199 }
38200 impl CooperativeMatrixPropertiesNV {
builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a>38201     pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> {
38202         CooperativeMatrixPropertiesNVBuilder {
38203             inner: CooperativeMatrixPropertiesNV::default(),
38204             marker: ::std::marker::PhantomData,
38205         }
38206     }
38207 }
38208 #[repr(transparent)]
38209 pub struct CooperativeMatrixPropertiesNVBuilder<'a> {
38210     inner: CooperativeMatrixPropertiesNV,
38211     marker: ::std::marker::PhantomData<&'a ()>,
38212 }
38213 pub unsafe trait ExtendsCooperativeMatrixPropertiesNV {}
38214 impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> {
38215     type Target = CooperativeMatrixPropertiesNV;
deref(&self) -> &Self::Target38216     fn deref(&self) -> &Self::Target {
38217         &self.inner
38218     }
38219 }
38220 impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38221     fn deref_mut(&mut self) -> &mut Self::Target {
38222         &mut self.inner
38223     }
38224 }
38225 impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
m_size(mut self, m_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a>38226     pub fn m_size(mut self, m_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38227         self.inner.m_size = m_size;
38228         self
38229     }
n_size(mut self, n_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a>38230     pub fn n_size(mut self, n_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38231         self.inner.n_size = n_size;
38232         self
38233     }
k_size(mut self, k_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a>38234     pub fn k_size(mut self, k_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38235         self.inner.k_size = k_size;
38236         self
38237     }
a_type(mut self, a_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a>38238     pub fn a_type(mut self, a_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38239         self.inner.a_type = a_type;
38240         self
38241     }
b_type(mut self, b_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a>38242     pub fn b_type(mut self, b_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38243         self.inner.b_type = b_type;
38244         self
38245     }
c_type(mut self, c_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a>38246     pub fn c_type(mut self, c_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38247         self.inner.c_type = c_type;
38248         self
38249     }
d_type(mut self, d_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a>38250     pub fn d_type(mut self, d_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38251         self.inner.d_type = d_type;
38252         self
38253     }
scope(mut self, scope: ScopeNV) -> CooperativeMatrixPropertiesNVBuilder<'a>38254     pub fn scope(mut self, scope: ScopeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38255         self.inner.scope = scope;
38256         self
38257     }
38258     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
38259     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
38260     #[doc = r" valid extension structs can be pushed into the chain."]
38261     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
38262     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCooperativeMatrixPropertiesNV>( mut self, next: &'a mut T, ) -> CooperativeMatrixPropertiesNVBuilder<'a>38263     pub fn push_next<T: ExtendsCooperativeMatrixPropertiesNV>(
38264         mut self,
38265         next: &'a mut T,
38266     ) -> CooperativeMatrixPropertiesNVBuilder<'a> {
38267         unsafe {
38268             let next_ptr = next as *mut T as *mut BaseOutStructure;
38269             let last_next = ptr_chain_iter(next).last().unwrap();
38270             (*last_next).p_next = self.inner.p_next as _;
38271             self.inner.p_next = next_ptr as _;
38272         }
38273         self
38274     }
38275     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38276     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38277     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CooperativeMatrixPropertiesNV38278     pub fn build(self) -> CooperativeMatrixPropertiesNV {
38279         self.inner
38280     }
38281 }
38282 #[repr(C)]
38283 #[derive(Copy, Clone, Debug)]
38284 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>"]
38285 pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
38286     pub s_type: StructureType,
38287     pub p_next: *mut c_void,
38288     pub ycbcr_image_arrays: Bool32,
38289 }
38290 impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
default() -> PhysicalDeviceYcbcrImageArraysFeaturesEXT38291     fn default() -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
38292         PhysicalDeviceYcbcrImageArraysFeaturesEXT {
38293             s_type: StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
38294             p_next: ::std::ptr::null_mut(),
38295             ycbcr_image_arrays: Bool32::default(),
38296         }
38297     }
38298 }
38299 impl PhysicalDeviceYcbcrImageArraysFeaturesEXT {
builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a>38300     pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
38301         PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder {
38302             inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT::default(),
38303             marker: ::std::marker::PhantomData,
38304         }
38305     }
38306 }
38307 #[repr(transparent)]
38308 pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
38309     inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT,
38310     marker: ::std::marker::PhantomData<&'a ()>,
38311 }
38312 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {}
38313 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
38314 impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
38315     type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
deref(&self) -> &Self::Target38316     fn deref(&self) -> &Self::Target {
38317         &self.inner
38318     }
38319 }
38320 impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38321     fn deref_mut(&mut self) -> &mut Self::Target {
38322         &mut self.inner
38323     }
38324 }
38325 impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
ycbcr_image_arrays( mut self, ycbcr_image_arrays: bool, ) -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a>38326     pub fn ycbcr_image_arrays(
38327         mut self,
38328         ycbcr_image_arrays: bool,
38329     ) -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
38330         self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into();
38331         self
38332     }
38333     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38334     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38335     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT38336     pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
38337         self.inner
38338     }
38339 }
38340 #[repr(C)]
38341 #[derive(Copy, Clone, Debug)]
38342 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewHandleInfoNVX.html>"]
38343 pub struct ImageViewHandleInfoNVX {
38344     pub s_type: StructureType,
38345     pub p_next: *const c_void,
38346     pub image_view: ImageView,
38347     pub descriptor_type: DescriptorType,
38348     pub sampler: Sampler,
38349 }
38350 impl ::std::default::Default for ImageViewHandleInfoNVX {
default() -> ImageViewHandleInfoNVX38351     fn default() -> ImageViewHandleInfoNVX {
38352         ImageViewHandleInfoNVX {
38353             s_type: StructureType::IMAGE_VIEW_HANDLE_INFO_NVX,
38354             p_next: ::std::ptr::null(),
38355             image_view: ImageView::default(),
38356             descriptor_type: DescriptorType::default(),
38357             sampler: Sampler::default(),
38358         }
38359     }
38360 }
38361 impl ImageViewHandleInfoNVX {
builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a>38362     pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> {
38363         ImageViewHandleInfoNVXBuilder {
38364             inner: ImageViewHandleInfoNVX::default(),
38365             marker: ::std::marker::PhantomData,
38366         }
38367     }
38368 }
38369 #[repr(transparent)]
38370 pub struct ImageViewHandleInfoNVXBuilder<'a> {
38371     inner: ImageViewHandleInfoNVX,
38372     marker: ::std::marker::PhantomData<&'a ()>,
38373 }
38374 pub unsafe trait ExtendsImageViewHandleInfoNVX {}
38375 impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> {
38376     type Target = ImageViewHandleInfoNVX;
deref(&self) -> &Self::Target38377     fn deref(&self) -> &Self::Target {
38378         &self.inner
38379     }
38380 }
38381 impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38382     fn deref_mut(&mut self) -> &mut Self::Target {
38383         &mut self.inner
38384     }
38385 }
38386 impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
image_view(mut self, image_view: ImageView) -> ImageViewHandleInfoNVXBuilder<'a>38387     pub fn image_view(mut self, image_view: ImageView) -> ImageViewHandleInfoNVXBuilder<'a> {
38388         self.inner.image_view = image_view;
38389         self
38390     }
descriptor_type( mut self, descriptor_type: DescriptorType, ) -> ImageViewHandleInfoNVXBuilder<'a>38391     pub fn descriptor_type(
38392         mut self,
38393         descriptor_type: DescriptorType,
38394     ) -> ImageViewHandleInfoNVXBuilder<'a> {
38395         self.inner.descriptor_type = descriptor_type;
38396         self
38397     }
sampler(mut self, sampler: Sampler) -> ImageViewHandleInfoNVXBuilder<'a>38398     pub fn sampler(mut self, sampler: Sampler) -> ImageViewHandleInfoNVXBuilder<'a> {
38399         self.inner.sampler = sampler;
38400         self
38401     }
38402     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
38403     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
38404     #[doc = r" valid extension structs can be pushed into the chain."]
38405     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
38406     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageViewHandleInfoNVX>( mut self, next: &'a mut T, ) -> ImageViewHandleInfoNVXBuilder<'a>38407     pub fn push_next<T: ExtendsImageViewHandleInfoNVX>(
38408         mut self,
38409         next: &'a mut T,
38410     ) -> ImageViewHandleInfoNVXBuilder<'a> {
38411         unsafe {
38412             let next_ptr = next as *mut T as *mut BaseOutStructure;
38413             let last_next = ptr_chain_iter(next).last().unwrap();
38414             (*last_next).p_next = self.inner.p_next as _;
38415             self.inner.p_next = next_ptr as _;
38416         }
38417         self
38418     }
38419     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38420     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38421     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewHandleInfoNVX38422     pub fn build(self) -> ImageViewHandleInfoNVX {
38423         self.inner
38424     }
38425 }
38426 #[repr(C)]
38427 #[derive(Copy, Clone, Debug)]
38428 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewAddressPropertiesNVX.html>"]
38429 pub struct ImageViewAddressPropertiesNVX {
38430     pub s_type: StructureType,
38431     pub p_next: *mut c_void,
38432     pub device_address: DeviceAddress,
38433     pub size: DeviceSize,
38434 }
38435 impl ::std::default::Default for ImageViewAddressPropertiesNVX {
default() -> ImageViewAddressPropertiesNVX38436     fn default() -> ImageViewAddressPropertiesNVX {
38437         ImageViewAddressPropertiesNVX {
38438             s_type: StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
38439             p_next: ::std::ptr::null_mut(),
38440             device_address: DeviceAddress::default(),
38441             size: DeviceSize::default(),
38442         }
38443     }
38444 }
38445 impl ImageViewAddressPropertiesNVX {
builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a>38446     pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> {
38447         ImageViewAddressPropertiesNVXBuilder {
38448             inner: ImageViewAddressPropertiesNVX::default(),
38449             marker: ::std::marker::PhantomData,
38450         }
38451     }
38452 }
38453 #[repr(transparent)]
38454 pub struct ImageViewAddressPropertiesNVXBuilder<'a> {
38455     inner: ImageViewAddressPropertiesNVX,
38456     marker: ::std::marker::PhantomData<&'a ()>,
38457 }
38458 pub unsafe trait ExtendsImageViewAddressPropertiesNVX {}
38459 impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> {
38460     type Target = ImageViewAddressPropertiesNVX;
deref(&self) -> &Self::Target38461     fn deref(&self) -> &Self::Target {
38462         &self.inner
38463     }
38464 }
38465 impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38466     fn deref_mut(&mut self) -> &mut Self::Target {
38467         &mut self.inner
38468     }
38469 }
38470 impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> {
device_address( mut self, device_address: DeviceAddress, ) -> ImageViewAddressPropertiesNVXBuilder<'a>38471     pub fn device_address(
38472         mut self,
38473         device_address: DeviceAddress,
38474     ) -> ImageViewAddressPropertiesNVXBuilder<'a> {
38475         self.inner.device_address = device_address;
38476         self
38477     }
size(mut self, size: DeviceSize) -> ImageViewAddressPropertiesNVXBuilder<'a>38478     pub fn size(mut self, size: DeviceSize) -> ImageViewAddressPropertiesNVXBuilder<'a> {
38479         self.inner.size = size;
38480         self
38481     }
38482     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
38483     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
38484     #[doc = r" valid extension structs can be pushed into the chain."]
38485     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
38486     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageViewAddressPropertiesNVX>( mut self, next: &'a mut T, ) -> ImageViewAddressPropertiesNVXBuilder<'a>38487     pub fn push_next<T: ExtendsImageViewAddressPropertiesNVX>(
38488         mut self,
38489         next: &'a mut T,
38490     ) -> ImageViewAddressPropertiesNVXBuilder<'a> {
38491         unsafe {
38492             let next_ptr = next as *mut T as *mut BaseOutStructure;
38493             let last_next = ptr_chain_iter(next).last().unwrap();
38494             (*last_next).p_next = self.inner.p_next as _;
38495             self.inner.p_next = next_ptr as _;
38496         }
38497         self
38498     }
38499     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38500     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38501     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageViewAddressPropertiesNVX38502     pub fn build(self) -> ImageViewAddressPropertiesNVX {
38503         self.inner
38504     }
38505 }
38506 #[repr(C)]
38507 #[derive(Copy, Clone, Debug)]
38508 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentFrameTokenGGP.html>"]
38509 pub struct PresentFrameTokenGGP {
38510     pub s_type: StructureType,
38511     pub p_next: *const c_void,
38512     pub frame_token: GgpFrameToken,
38513 }
38514 impl ::std::default::Default for PresentFrameTokenGGP {
default() -> PresentFrameTokenGGP38515     fn default() -> PresentFrameTokenGGP {
38516         PresentFrameTokenGGP {
38517             s_type: StructureType::PRESENT_FRAME_TOKEN_GGP,
38518             p_next: ::std::ptr::null(),
38519             frame_token: GgpFrameToken::default(),
38520         }
38521     }
38522 }
38523 impl PresentFrameTokenGGP {
builder<'a>() -> PresentFrameTokenGGPBuilder<'a>38524     pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> {
38525         PresentFrameTokenGGPBuilder {
38526             inner: PresentFrameTokenGGP::default(),
38527             marker: ::std::marker::PhantomData,
38528         }
38529     }
38530 }
38531 #[repr(transparent)]
38532 pub struct PresentFrameTokenGGPBuilder<'a> {
38533     inner: PresentFrameTokenGGP,
38534     marker: ::std::marker::PhantomData<&'a ()>,
38535 }
38536 unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {}
38537 unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {}
38538 impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> {
38539     type Target = PresentFrameTokenGGP;
deref(&self) -> &Self::Target38540     fn deref(&self) -> &Self::Target {
38541         &self.inner
38542     }
38543 }
38544 impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38545     fn deref_mut(&mut self) -> &mut Self::Target {
38546         &mut self.inner
38547     }
38548 }
38549 impl<'a> PresentFrameTokenGGPBuilder<'a> {
frame_token(mut self, frame_token: GgpFrameToken) -> PresentFrameTokenGGPBuilder<'a>38550     pub fn frame_token(mut self, frame_token: GgpFrameToken) -> PresentFrameTokenGGPBuilder<'a> {
38551         self.inner.frame_token = frame_token;
38552         self
38553     }
38554     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38555     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38556     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PresentFrameTokenGGP38557     pub fn build(self) -> PresentFrameTokenGGP {
38558         self.inner
38559     }
38560 }
38561 #[repr(C)]
38562 #[derive(Copy, Clone, Default, Debug)]
38563 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackEXT.html>"]
38564 pub struct PipelineCreationFeedbackEXT {
38565     pub flags: PipelineCreationFeedbackFlagsEXT,
38566     pub duration: u64,
38567 }
38568 impl PipelineCreationFeedbackEXT {
builder<'a>() -> PipelineCreationFeedbackEXTBuilder<'a>38569     pub fn builder<'a>() -> PipelineCreationFeedbackEXTBuilder<'a> {
38570         PipelineCreationFeedbackEXTBuilder {
38571             inner: PipelineCreationFeedbackEXT::default(),
38572             marker: ::std::marker::PhantomData,
38573         }
38574     }
38575 }
38576 #[repr(transparent)]
38577 pub struct PipelineCreationFeedbackEXTBuilder<'a> {
38578     inner: PipelineCreationFeedbackEXT,
38579     marker: ::std::marker::PhantomData<&'a ()>,
38580 }
38581 impl<'a> ::std::ops::Deref for PipelineCreationFeedbackEXTBuilder<'a> {
38582     type Target = PipelineCreationFeedbackEXT;
deref(&self) -> &Self::Target38583     fn deref(&self) -> &Self::Target {
38584         &self.inner
38585     }
38586 }
38587 impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38588     fn deref_mut(&mut self) -> &mut Self::Target {
38589         &mut self.inner
38590     }
38591 }
38592 impl<'a> PipelineCreationFeedbackEXTBuilder<'a> {
flags( mut self, flags: PipelineCreationFeedbackFlagsEXT, ) -> PipelineCreationFeedbackEXTBuilder<'a>38593     pub fn flags(
38594         mut self,
38595         flags: PipelineCreationFeedbackFlagsEXT,
38596     ) -> PipelineCreationFeedbackEXTBuilder<'a> {
38597         self.inner.flags = flags;
38598         self
38599     }
duration(mut self, duration: u64) -> PipelineCreationFeedbackEXTBuilder<'a>38600     pub fn duration(mut self, duration: u64) -> PipelineCreationFeedbackEXTBuilder<'a> {
38601         self.inner.duration = duration;
38602         self
38603     }
38604     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38605     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38606     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCreationFeedbackEXT38607     pub fn build(self) -> PipelineCreationFeedbackEXT {
38608         self.inner
38609     }
38610 }
38611 #[repr(C)]
38612 #[derive(Copy, Clone, Debug)]
38613 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackCreateInfoEXT.html>"]
38614 pub struct PipelineCreationFeedbackCreateInfoEXT {
38615     pub s_type: StructureType,
38616     pub p_next: *const c_void,
38617     pub p_pipeline_creation_feedback: *mut PipelineCreationFeedbackEXT,
38618     pub pipeline_stage_creation_feedback_count: u32,
38619     pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedbackEXT,
38620 }
38621 impl ::std::default::Default for PipelineCreationFeedbackCreateInfoEXT {
default() -> PipelineCreationFeedbackCreateInfoEXT38622     fn default() -> PipelineCreationFeedbackCreateInfoEXT {
38623         PipelineCreationFeedbackCreateInfoEXT {
38624             s_type: StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT,
38625             p_next: ::std::ptr::null(),
38626             p_pipeline_creation_feedback: ::std::ptr::null_mut(),
38627             pipeline_stage_creation_feedback_count: u32::default(),
38628             p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(),
38629         }
38630     }
38631 }
38632 impl PipelineCreationFeedbackCreateInfoEXT {
builder<'a>() -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a>38633     pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
38634         PipelineCreationFeedbackCreateInfoEXTBuilder {
38635             inner: PipelineCreationFeedbackCreateInfoEXT::default(),
38636             marker: ::std::marker::PhantomData,
38637         }
38638     }
38639 }
38640 #[repr(transparent)]
38641 pub struct PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
38642     inner: PipelineCreationFeedbackCreateInfoEXT,
38643     marker: ::std::marker::PhantomData<&'a ()>,
38644 }
38645 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXTBuilder<'_> {}
38646 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXT {}
38647 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXTBuilder<'_> {}
38648 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXT {}
38649 unsafe impl ExtendsRayTracingPipelineCreateInfoNV
38650     for PipelineCreationFeedbackCreateInfoEXTBuilder<'_>
38651 {
38652 }
38653 unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfoEXT {}
38654 unsafe impl ExtendsRayTracingPipelineCreateInfoKHR
38655     for PipelineCreationFeedbackCreateInfoEXTBuilder<'_>
38656 {
38657 }
38658 unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfoEXT {}
38659 impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
38660     type Target = PipelineCreationFeedbackCreateInfoEXT;
deref(&self) -> &Self::Target38661     fn deref(&self) -> &Self::Target {
38662         &self.inner
38663     }
38664 }
38665 impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38666     fn deref_mut(&mut self) -> &mut Self::Target {
38667         &mut self.inner
38668     }
38669 }
38670 impl<'a> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
pipeline_creation_feedback( mut self, pipeline_creation_feedback: &'a mut PipelineCreationFeedbackEXT, ) -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a>38671     pub fn pipeline_creation_feedback(
38672         mut self,
38673         pipeline_creation_feedback: &'a mut PipelineCreationFeedbackEXT,
38674     ) -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
38675         self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback;
38676         self
38677     }
pipeline_stage_creation_feedbacks( mut self, pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedbackEXT], ) -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a>38678     pub fn pipeline_stage_creation_feedbacks(
38679         mut self,
38680         pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedbackEXT],
38681     ) -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
38682         self.inner.pipeline_stage_creation_feedback_count =
38683             pipeline_stage_creation_feedbacks.len() as _;
38684         self.inner.p_pipeline_stage_creation_feedbacks =
38685             pipeline_stage_creation_feedbacks.as_mut_ptr();
38686         self
38687     }
38688     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38689     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38690     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCreationFeedbackCreateInfoEXT38691     pub fn build(self) -> PipelineCreationFeedbackCreateInfoEXT {
38692         self.inner
38693     }
38694 }
38695 #[repr(C)]
38696 #[derive(Copy, Clone, Debug)]
38697 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>"]
38698 pub struct SurfaceFullScreenExclusiveInfoEXT {
38699     pub s_type: StructureType,
38700     pub p_next: *mut c_void,
38701     pub full_screen_exclusive: FullScreenExclusiveEXT,
38702 }
38703 impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT {
default() -> SurfaceFullScreenExclusiveInfoEXT38704     fn default() -> SurfaceFullScreenExclusiveInfoEXT {
38705         SurfaceFullScreenExclusiveInfoEXT {
38706             s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
38707             p_next: ::std::ptr::null_mut(),
38708             full_screen_exclusive: FullScreenExclusiveEXT::default(),
38709         }
38710     }
38711 }
38712 impl SurfaceFullScreenExclusiveInfoEXT {
builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a>38713     pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
38714         SurfaceFullScreenExclusiveInfoEXTBuilder {
38715             inner: SurfaceFullScreenExclusiveInfoEXT::default(),
38716             marker: ::std::marker::PhantomData,
38717         }
38718     }
38719 }
38720 #[repr(transparent)]
38721 pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
38722     inner: SurfaceFullScreenExclusiveInfoEXT,
38723     marker: ::std::marker::PhantomData<&'a ()>,
38724 }
38725 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
38726 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {}
38727 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
38728 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {}
38729 impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
38730     type Target = SurfaceFullScreenExclusiveInfoEXT;
deref(&self) -> &Self::Target38731     fn deref(&self) -> &Self::Target {
38732         &self.inner
38733     }
38734 }
38735 impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38736     fn deref_mut(&mut self) -> &mut Self::Target {
38737         &mut self.inner
38738     }
38739 }
38740 impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
full_screen_exclusive( mut self, full_screen_exclusive: FullScreenExclusiveEXT, ) -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a>38741     pub fn full_screen_exclusive(
38742         mut self,
38743         full_screen_exclusive: FullScreenExclusiveEXT,
38744     ) -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
38745         self.inner.full_screen_exclusive = full_screen_exclusive;
38746         self
38747     }
38748     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38749     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38750     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFullScreenExclusiveInfoEXT38751     pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT {
38752         self.inner
38753     }
38754 }
38755 #[repr(C)]
38756 #[derive(Copy, Clone, Debug)]
38757 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>"]
38758 pub struct SurfaceFullScreenExclusiveWin32InfoEXT {
38759     pub s_type: StructureType,
38760     pub p_next: *const c_void,
38761     pub hmonitor: HMONITOR,
38762 }
38763 impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT {
default() -> SurfaceFullScreenExclusiveWin32InfoEXT38764     fn default() -> SurfaceFullScreenExclusiveWin32InfoEXT {
38765         SurfaceFullScreenExclusiveWin32InfoEXT {
38766             s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
38767             p_next: ::std::ptr::null(),
38768             hmonitor: unsafe { ::std::mem::zeroed() },
38769         }
38770     }
38771 }
38772 impl SurfaceFullScreenExclusiveWin32InfoEXT {
builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a>38773     pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
38774         SurfaceFullScreenExclusiveWin32InfoEXTBuilder {
38775             inner: SurfaceFullScreenExclusiveWin32InfoEXT::default(),
38776             marker: ::std::marker::PhantomData,
38777         }
38778     }
38779 }
38780 #[repr(transparent)]
38781 pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
38782     inner: SurfaceFullScreenExclusiveWin32InfoEXT,
38783     marker: ::std::marker::PhantomData<&'a ()>,
38784 }
38785 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR
38786     for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_>
38787 {
38788 }
38789 unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
38790 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {}
38791 unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
38792 impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
38793     type Target = SurfaceFullScreenExclusiveWin32InfoEXT;
deref(&self) -> &Self::Target38794     fn deref(&self) -> &Self::Target {
38795         &self.inner
38796     }
38797 }
38798 impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38799     fn deref_mut(&mut self) -> &mut Self::Target {
38800         &mut self.inner
38801     }
38802 }
38803 impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
hmonitor( mut self, hmonitor: HMONITOR, ) -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a>38804     pub fn hmonitor(
38805         mut self,
38806         hmonitor: HMONITOR,
38807     ) -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
38808         self.inner.hmonitor = hmonitor;
38809         self
38810     }
38811     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38812     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38813     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT38814     pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT {
38815         self.inner
38816     }
38817 }
38818 #[repr(C)]
38819 #[derive(Copy, Clone, Debug)]
38820 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>"]
38821 pub struct SurfaceCapabilitiesFullScreenExclusiveEXT {
38822     pub s_type: StructureType,
38823     pub p_next: *mut c_void,
38824     pub full_screen_exclusive_supported: Bool32,
38825 }
38826 impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT {
default() -> SurfaceCapabilitiesFullScreenExclusiveEXT38827     fn default() -> SurfaceCapabilitiesFullScreenExclusiveEXT {
38828         SurfaceCapabilitiesFullScreenExclusiveEXT {
38829             s_type: StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
38830             p_next: ::std::ptr::null_mut(),
38831             full_screen_exclusive_supported: Bool32::default(),
38832         }
38833     }
38834 }
38835 impl SurfaceCapabilitiesFullScreenExclusiveEXT {
builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a>38836     pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
38837         SurfaceCapabilitiesFullScreenExclusiveEXTBuilder {
38838             inner: SurfaceCapabilitiesFullScreenExclusiveEXT::default(),
38839             marker: ::std::marker::PhantomData,
38840         }
38841     }
38842 }
38843 #[repr(transparent)]
38844 pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
38845     inner: SurfaceCapabilitiesFullScreenExclusiveEXT,
38846     marker: ::std::marker::PhantomData<&'a ()>,
38847 }
38848 unsafe impl ExtendsSurfaceCapabilities2KHR
38849     for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_>
38850 {
38851 }
38852 unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {}
38853 impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
38854     type Target = SurfaceCapabilitiesFullScreenExclusiveEXT;
deref(&self) -> &Self::Target38855     fn deref(&self) -> &Self::Target {
38856         &self.inner
38857     }
38858 }
38859 impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38860     fn deref_mut(&mut self) -> &mut Self::Target {
38861         &mut self.inner
38862     }
38863 }
38864 impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
full_screen_exclusive_supported( mut self, full_screen_exclusive_supported: bool, ) -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a>38865     pub fn full_screen_exclusive_supported(
38866         mut self,
38867         full_screen_exclusive_supported: bool,
38868     ) -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
38869         self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into();
38870         self
38871     }
38872     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38873     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38874     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT38875     pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT {
38876         self.inner
38877     }
38878 }
38879 #[repr(C)]
38880 #[derive(Copy, Clone, Debug)]
38881 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>"]
38882 pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
38883     pub s_type: StructureType,
38884     pub p_next: *mut c_void,
38885     pub performance_counter_query_pools: Bool32,
38886     pub performance_counter_multiple_query_pools: Bool32,
38887 }
38888 impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR {
default() -> PhysicalDevicePerformanceQueryFeaturesKHR38889     fn default() -> PhysicalDevicePerformanceQueryFeaturesKHR {
38890         PhysicalDevicePerformanceQueryFeaturesKHR {
38891             s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
38892             p_next: ::std::ptr::null_mut(),
38893             performance_counter_query_pools: Bool32::default(),
38894             performance_counter_multiple_query_pools: Bool32::default(),
38895         }
38896     }
38897 }
38898 impl PhysicalDevicePerformanceQueryFeaturesKHR {
builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a>38899     pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
38900         PhysicalDevicePerformanceQueryFeaturesKHRBuilder {
38901             inner: PhysicalDevicePerformanceQueryFeaturesKHR::default(),
38902             marker: ::std::marker::PhantomData,
38903         }
38904     }
38905 }
38906 #[repr(transparent)]
38907 pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
38908     inner: PhysicalDevicePerformanceQueryFeaturesKHR,
38909     marker: ::std::marker::PhantomData<&'a ()>,
38910 }
38911 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {}
38912 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {}
38913 impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
38914     type Target = PhysicalDevicePerformanceQueryFeaturesKHR;
deref(&self) -> &Self::Target38915     fn deref(&self) -> &Self::Target {
38916         &self.inner
38917     }
38918 }
38919 impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38920     fn deref_mut(&mut self) -> &mut Self::Target {
38921         &mut self.inner
38922     }
38923 }
38924 impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
performance_counter_query_pools( mut self, performance_counter_query_pools: bool, ) -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a>38925     pub fn performance_counter_query_pools(
38926         mut self,
38927         performance_counter_query_pools: bool,
38928     ) -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
38929         self.inner.performance_counter_query_pools = performance_counter_query_pools.into();
38930         self
38931     }
performance_counter_multiple_query_pools( mut self, performance_counter_multiple_query_pools: bool, ) -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a>38932     pub fn performance_counter_multiple_query_pools(
38933         mut self,
38934         performance_counter_multiple_query_pools: bool,
38935     ) -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
38936         self.inner.performance_counter_multiple_query_pools =
38937             performance_counter_multiple_query_pools.into();
38938         self
38939     }
38940     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
38941     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
38942     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR38943     pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR {
38944         self.inner
38945     }
38946 }
38947 #[repr(C)]
38948 #[derive(Copy, Clone, Debug)]
38949 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>"]
38950 pub struct PhysicalDevicePerformanceQueryPropertiesKHR {
38951     pub s_type: StructureType,
38952     pub p_next: *mut c_void,
38953     pub allow_command_buffer_query_copies: Bool32,
38954 }
38955 impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR {
default() -> PhysicalDevicePerformanceQueryPropertiesKHR38956     fn default() -> PhysicalDevicePerformanceQueryPropertiesKHR {
38957         PhysicalDevicePerformanceQueryPropertiesKHR {
38958             s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
38959             p_next: ::std::ptr::null_mut(),
38960             allow_command_buffer_query_copies: Bool32::default(),
38961         }
38962     }
38963 }
38964 impl PhysicalDevicePerformanceQueryPropertiesKHR {
builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a>38965     pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
38966         PhysicalDevicePerformanceQueryPropertiesKHRBuilder {
38967             inner: PhysicalDevicePerformanceQueryPropertiesKHR::default(),
38968             marker: ::std::marker::PhantomData,
38969         }
38970     }
38971 }
38972 #[repr(transparent)]
38973 pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
38974     inner: PhysicalDevicePerformanceQueryPropertiesKHR,
38975     marker: ::std::marker::PhantomData<&'a ()>,
38976 }
38977 unsafe impl ExtendsPhysicalDeviceProperties2
38978     for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_>
38979 {
38980 }
38981 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {}
38982 impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
38983     type Target = PhysicalDevicePerformanceQueryPropertiesKHR;
deref(&self) -> &Self::Target38984     fn deref(&self) -> &Self::Target {
38985         &self.inner
38986     }
38987 }
38988 impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target38989     fn deref_mut(&mut self) -> &mut Self::Target {
38990         &mut self.inner
38991     }
38992 }
38993 impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
allow_command_buffer_query_copies( mut self, allow_command_buffer_query_copies: bool, ) -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a>38994     pub fn allow_command_buffer_query_copies(
38995         mut self,
38996         allow_command_buffer_query_copies: bool,
38997     ) -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
38998         self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into();
38999         self
39000     }
39001     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39002     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39003     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR39004     pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR {
39005         self.inner
39006     }
39007 }
39008 #[repr(C)]
39009 #[derive(Copy, Clone, Debug)]
39010 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterKHR.html>"]
39011 pub struct PerformanceCounterKHR {
39012     pub s_type: StructureType,
39013     pub p_next: *const c_void,
39014     pub unit: PerformanceCounterUnitKHR,
39015     pub scope: PerformanceCounterScopeKHR,
39016     pub storage: PerformanceCounterStorageKHR,
39017     pub uuid: [u8; UUID_SIZE],
39018 }
39019 impl ::std::default::Default for PerformanceCounterKHR {
default() -> PerformanceCounterKHR39020     fn default() -> PerformanceCounterKHR {
39021         PerformanceCounterKHR {
39022             s_type: StructureType::PERFORMANCE_COUNTER_KHR,
39023             p_next: ::std::ptr::null(),
39024             unit: PerformanceCounterUnitKHR::default(),
39025             scope: PerformanceCounterScopeKHR::default(),
39026             storage: PerformanceCounterStorageKHR::default(),
39027             uuid: unsafe { ::std::mem::zeroed() },
39028         }
39029     }
39030 }
39031 impl PerformanceCounterKHR {
builder<'a>() -> PerformanceCounterKHRBuilder<'a>39032     pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> {
39033         PerformanceCounterKHRBuilder {
39034             inner: PerformanceCounterKHR::default(),
39035             marker: ::std::marker::PhantomData,
39036         }
39037     }
39038 }
39039 #[repr(transparent)]
39040 pub struct PerformanceCounterKHRBuilder<'a> {
39041     inner: PerformanceCounterKHR,
39042     marker: ::std::marker::PhantomData<&'a ()>,
39043 }
39044 pub unsafe trait ExtendsPerformanceCounterKHR {}
39045 impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> {
39046     type Target = PerformanceCounterKHR;
deref(&self) -> &Self::Target39047     fn deref(&self) -> &Self::Target {
39048         &self.inner
39049     }
39050 }
39051 impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39052     fn deref_mut(&mut self) -> &mut Self::Target {
39053         &mut self.inner
39054     }
39055 }
39056 impl<'a> PerformanceCounterKHRBuilder<'a> {
unit(mut self, unit: PerformanceCounterUnitKHR) -> PerformanceCounterKHRBuilder<'a>39057     pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> PerformanceCounterKHRBuilder<'a> {
39058         self.inner.unit = unit;
39059         self
39060     }
scope(mut self, scope: PerformanceCounterScopeKHR) -> PerformanceCounterKHRBuilder<'a>39061     pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> PerformanceCounterKHRBuilder<'a> {
39062         self.inner.scope = scope;
39063         self
39064     }
storage( mut self, storage: PerformanceCounterStorageKHR, ) -> PerformanceCounterKHRBuilder<'a>39065     pub fn storage(
39066         mut self,
39067         storage: PerformanceCounterStorageKHR,
39068     ) -> PerformanceCounterKHRBuilder<'a> {
39069         self.inner.storage = storage;
39070         self
39071     }
uuid(mut self, uuid: [u8; UUID_SIZE]) -> PerformanceCounterKHRBuilder<'a>39072     pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> PerformanceCounterKHRBuilder<'a> {
39073         self.inner.uuid = uuid;
39074         self
39075     }
39076     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
39077     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
39078     #[doc = r" valid extension structs can be pushed into the chain."]
39079     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
39080     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPerformanceCounterKHR>( mut self, next: &'a mut T, ) -> PerformanceCounterKHRBuilder<'a>39081     pub fn push_next<T: ExtendsPerformanceCounterKHR>(
39082         mut self,
39083         next: &'a mut T,
39084     ) -> PerformanceCounterKHRBuilder<'a> {
39085         unsafe {
39086             let next_ptr = next as *mut T as *mut BaseOutStructure;
39087             let last_next = ptr_chain_iter(next).last().unwrap();
39088             (*last_next).p_next = self.inner.p_next as _;
39089             self.inner.p_next = next_ptr as _;
39090         }
39091         self
39092     }
39093     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39094     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39095     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceCounterKHR39096     pub fn build(self) -> PerformanceCounterKHR {
39097         self.inner
39098     }
39099 }
39100 #[repr(C)]
39101 #[derive(Copy, Clone)]
39102 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionKHR.html>"]
39103 pub struct PerformanceCounterDescriptionKHR {
39104     pub s_type: StructureType,
39105     pub p_next: *const c_void,
39106     pub flags: PerformanceCounterDescriptionFlagsKHR,
39107     pub name: [c_char; MAX_DESCRIPTION_SIZE],
39108     pub category: [c_char; MAX_DESCRIPTION_SIZE],
39109     pub description: [c_char; MAX_DESCRIPTION_SIZE],
39110 }
39111 impl fmt::Debug for PerformanceCounterDescriptionKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result39112     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
39113         fmt.debug_struct("PerformanceCounterDescriptionKHR")
39114             .field("s_type", &self.s_type)
39115             .field("p_next", &self.p_next)
39116             .field("flags", &self.flags)
39117             .field("name", &unsafe {
39118                 ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
39119             })
39120             .field("category", &unsafe {
39121                 ::std::ffi::CStr::from_ptr(self.category.as_ptr() as *const c_char)
39122             })
39123             .field("description", &unsafe {
39124                 ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
39125             })
39126             .finish()
39127     }
39128 }
39129 impl ::std::default::Default for PerformanceCounterDescriptionKHR {
default() -> PerformanceCounterDescriptionKHR39130     fn default() -> PerformanceCounterDescriptionKHR {
39131         PerformanceCounterDescriptionKHR {
39132             s_type: StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR,
39133             p_next: ::std::ptr::null(),
39134             flags: PerformanceCounterDescriptionFlagsKHR::default(),
39135             name: unsafe { ::std::mem::zeroed() },
39136             category: unsafe { ::std::mem::zeroed() },
39137             description: unsafe { ::std::mem::zeroed() },
39138         }
39139     }
39140 }
39141 impl PerformanceCounterDescriptionKHR {
builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a>39142     pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> {
39143         PerformanceCounterDescriptionKHRBuilder {
39144             inner: PerformanceCounterDescriptionKHR::default(),
39145             marker: ::std::marker::PhantomData,
39146         }
39147     }
39148 }
39149 #[repr(transparent)]
39150 pub struct PerformanceCounterDescriptionKHRBuilder<'a> {
39151     inner: PerformanceCounterDescriptionKHR,
39152     marker: ::std::marker::PhantomData<&'a ()>,
39153 }
39154 pub unsafe trait ExtendsPerformanceCounterDescriptionKHR {}
39155 impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> {
39156     type Target = PerformanceCounterDescriptionKHR;
deref(&self) -> &Self::Target39157     fn deref(&self) -> &Self::Target {
39158         &self.inner
39159     }
39160 }
39161 impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39162     fn deref_mut(&mut self) -> &mut Self::Target {
39163         &mut self.inner
39164     }
39165 }
39166 impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
flags( mut self, flags: PerformanceCounterDescriptionFlagsKHR, ) -> PerformanceCounterDescriptionKHRBuilder<'a>39167     pub fn flags(
39168         mut self,
39169         flags: PerformanceCounterDescriptionFlagsKHR,
39170     ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
39171         self.inner.flags = flags;
39172         self
39173     }
name( mut self, name: [c_char; MAX_DESCRIPTION_SIZE], ) -> PerformanceCounterDescriptionKHRBuilder<'a>39174     pub fn name(
39175         mut self,
39176         name: [c_char; MAX_DESCRIPTION_SIZE],
39177     ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
39178         self.inner.name = name;
39179         self
39180     }
category( mut self, category: [c_char; MAX_DESCRIPTION_SIZE], ) -> PerformanceCounterDescriptionKHRBuilder<'a>39181     pub fn category(
39182         mut self,
39183         category: [c_char; MAX_DESCRIPTION_SIZE],
39184     ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
39185         self.inner.category = category;
39186         self
39187     }
description( mut self, description: [c_char; MAX_DESCRIPTION_SIZE], ) -> PerformanceCounterDescriptionKHRBuilder<'a>39188     pub fn description(
39189         mut self,
39190         description: [c_char; MAX_DESCRIPTION_SIZE],
39191     ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
39192         self.inner.description = description;
39193         self
39194     }
39195     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
39196     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
39197     #[doc = r" valid extension structs can be pushed into the chain."]
39198     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
39199     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPerformanceCounterDescriptionKHR>( mut self, next: &'a mut T, ) -> PerformanceCounterDescriptionKHRBuilder<'a>39200     pub fn push_next<T: ExtendsPerformanceCounterDescriptionKHR>(
39201         mut self,
39202         next: &'a mut T,
39203     ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
39204         unsafe {
39205             let next_ptr = next as *mut T as *mut BaseOutStructure;
39206             let last_next = ptr_chain_iter(next).last().unwrap();
39207             (*last_next).p_next = self.inner.p_next as _;
39208             self.inner.p_next = next_ptr as _;
39209         }
39210         self
39211     }
39212     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39213     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39214     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceCounterDescriptionKHR39215     pub fn build(self) -> PerformanceCounterDescriptionKHR {
39216         self.inner
39217     }
39218 }
39219 #[repr(C)]
39220 #[derive(Copy, Clone, Debug)]
39221 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>"]
39222 pub struct QueryPoolPerformanceCreateInfoKHR {
39223     pub s_type: StructureType,
39224     pub p_next: *const c_void,
39225     pub queue_family_index: u32,
39226     pub counter_index_count: u32,
39227     pub p_counter_indices: *const u32,
39228 }
39229 impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR {
default() -> QueryPoolPerformanceCreateInfoKHR39230     fn default() -> QueryPoolPerformanceCreateInfoKHR {
39231         QueryPoolPerformanceCreateInfoKHR {
39232             s_type: StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
39233             p_next: ::std::ptr::null(),
39234             queue_family_index: u32::default(),
39235             counter_index_count: u32::default(),
39236             p_counter_indices: ::std::ptr::null(),
39237         }
39238     }
39239 }
39240 impl QueryPoolPerformanceCreateInfoKHR {
builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a>39241     pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
39242         QueryPoolPerformanceCreateInfoKHRBuilder {
39243             inner: QueryPoolPerformanceCreateInfoKHR::default(),
39244             marker: ::std::marker::PhantomData,
39245         }
39246     }
39247 }
39248 #[repr(transparent)]
39249 pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
39250     inner: QueryPoolPerformanceCreateInfoKHR,
39251     marker: ::std::marker::PhantomData<&'a ()>,
39252 }
39253 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {}
39254 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {}
39255 impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
39256     type Target = QueryPoolPerformanceCreateInfoKHR;
deref(&self) -> &Self::Target39257     fn deref(&self) -> &Self::Target {
39258         &self.inner
39259     }
39260 }
39261 impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39262     fn deref_mut(&mut self) -> &mut Self::Target {
39263         &mut self.inner
39264     }
39265 }
39266 impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
queue_family_index( mut self, queue_family_index: u32, ) -> QueryPoolPerformanceCreateInfoKHRBuilder<'a>39267     pub fn queue_family_index(
39268         mut self,
39269         queue_family_index: u32,
39270     ) -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
39271         self.inner.queue_family_index = queue_family_index;
39272         self
39273     }
counter_indices( mut self, counter_indices: &'a [u32], ) -> QueryPoolPerformanceCreateInfoKHRBuilder<'a>39274     pub fn counter_indices(
39275         mut self,
39276         counter_indices: &'a [u32],
39277     ) -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
39278         self.inner.counter_index_count = counter_indices.len() as _;
39279         self.inner.p_counter_indices = counter_indices.as_ptr();
39280         self
39281     }
39282     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39283     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39284     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> QueryPoolPerformanceCreateInfoKHR39285     pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR {
39286         self.inner
39287     }
39288 }
39289 #[repr(C)]
39290 #[derive(Copy, Clone)]
39291 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterResultKHR.html>"]
39292 pub union PerformanceCounterResultKHR {
39293     pub int32: i32,
39294     pub int64: i64,
39295     pub uint32: u32,
39296     pub uint64: u64,
39297     pub float32: f32,
39298     pub float64: f64,
39299 }
39300 impl ::std::default::Default for PerformanceCounterResultKHR {
default() -> PerformanceCounterResultKHR39301     fn default() -> PerformanceCounterResultKHR {
39302         unsafe { ::std::mem::zeroed() }
39303     }
39304 }
39305 #[repr(C)]
39306 #[derive(Copy, Clone, Debug)]
39307 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockInfoKHR.html>"]
39308 pub struct AcquireProfilingLockInfoKHR {
39309     pub s_type: StructureType,
39310     pub p_next: *const c_void,
39311     pub flags: AcquireProfilingLockFlagsKHR,
39312     pub timeout: u64,
39313 }
39314 impl ::std::default::Default for AcquireProfilingLockInfoKHR {
default() -> AcquireProfilingLockInfoKHR39315     fn default() -> AcquireProfilingLockInfoKHR {
39316         AcquireProfilingLockInfoKHR {
39317             s_type: StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR,
39318             p_next: ::std::ptr::null(),
39319             flags: AcquireProfilingLockFlagsKHR::default(),
39320             timeout: u64::default(),
39321         }
39322     }
39323 }
39324 impl AcquireProfilingLockInfoKHR {
builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a>39325     pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> {
39326         AcquireProfilingLockInfoKHRBuilder {
39327             inner: AcquireProfilingLockInfoKHR::default(),
39328             marker: ::std::marker::PhantomData,
39329         }
39330     }
39331 }
39332 #[repr(transparent)]
39333 pub struct AcquireProfilingLockInfoKHRBuilder<'a> {
39334     inner: AcquireProfilingLockInfoKHR,
39335     marker: ::std::marker::PhantomData<&'a ()>,
39336 }
39337 pub unsafe trait ExtendsAcquireProfilingLockInfoKHR {}
39338 impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> {
39339     type Target = AcquireProfilingLockInfoKHR;
deref(&self) -> &Self::Target39340     fn deref(&self) -> &Self::Target {
39341         &self.inner
39342     }
39343 }
39344 impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39345     fn deref_mut(&mut self) -> &mut Self::Target {
39346         &mut self.inner
39347     }
39348 }
39349 impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
flags( mut self, flags: AcquireProfilingLockFlagsKHR, ) -> AcquireProfilingLockInfoKHRBuilder<'a>39350     pub fn flags(
39351         mut self,
39352         flags: AcquireProfilingLockFlagsKHR,
39353     ) -> AcquireProfilingLockInfoKHRBuilder<'a> {
39354         self.inner.flags = flags;
39355         self
39356     }
timeout(mut self, timeout: u64) -> AcquireProfilingLockInfoKHRBuilder<'a>39357     pub fn timeout(mut self, timeout: u64) -> AcquireProfilingLockInfoKHRBuilder<'a> {
39358         self.inner.timeout = timeout;
39359         self
39360     }
39361     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
39362     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
39363     #[doc = r" valid extension structs can be pushed into the chain."]
39364     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
39365     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAcquireProfilingLockInfoKHR>( mut self, next: &'a mut T, ) -> AcquireProfilingLockInfoKHRBuilder<'a>39366     pub fn push_next<T: ExtendsAcquireProfilingLockInfoKHR>(
39367         mut self,
39368         next: &'a mut T,
39369     ) -> AcquireProfilingLockInfoKHRBuilder<'a> {
39370         unsafe {
39371             let next_ptr = next as *mut T as *mut BaseOutStructure;
39372             let last_next = ptr_chain_iter(next).last().unwrap();
39373             (*last_next).p_next = self.inner.p_next as _;
39374             self.inner.p_next = next_ptr as _;
39375         }
39376         self
39377     }
39378     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39379     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39380     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AcquireProfilingLockInfoKHR39381     pub fn build(self) -> AcquireProfilingLockInfoKHR {
39382         self.inner
39383     }
39384 }
39385 #[repr(C)]
39386 #[derive(Copy, Clone, Debug)]
39387 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html>"]
39388 pub struct PerformanceQuerySubmitInfoKHR {
39389     pub s_type: StructureType,
39390     pub p_next: *const c_void,
39391     pub counter_pass_index: u32,
39392 }
39393 impl ::std::default::Default for PerformanceQuerySubmitInfoKHR {
default() -> PerformanceQuerySubmitInfoKHR39394     fn default() -> PerformanceQuerySubmitInfoKHR {
39395         PerformanceQuerySubmitInfoKHR {
39396             s_type: StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
39397             p_next: ::std::ptr::null(),
39398             counter_pass_index: u32::default(),
39399         }
39400     }
39401 }
39402 impl PerformanceQuerySubmitInfoKHR {
builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a>39403     pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
39404         PerformanceQuerySubmitInfoKHRBuilder {
39405             inner: PerformanceQuerySubmitInfoKHR::default(),
39406             marker: ::std::marker::PhantomData,
39407         }
39408     }
39409 }
39410 #[repr(transparent)]
39411 pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
39412     inner: PerformanceQuerySubmitInfoKHR,
39413     marker: ::std::marker::PhantomData<&'a ()>,
39414 }
39415 unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
39416 unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {}
39417 impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
39418     type Target = PerformanceQuerySubmitInfoKHR;
deref(&self) -> &Self::Target39419     fn deref(&self) -> &Self::Target {
39420         &self.inner
39421     }
39422 }
39423 impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39424     fn deref_mut(&mut self) -> &mut Self::Target {
39425         &mut self.inner
39426     }
39427 }
39428 impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
counter_pass_index( mut self, counter_pass_index: u32, ) -> PerformanceQuerySubmitInfoKHRBuilder<'a>39429     pub fn counter_pass_index(
39430         mut self,
39431         counter_pass_index: u32,
39432     ) -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
39433         self.inner.counter_pass_index = counter_pass_index;
39434         self
39435     }
39436     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39437     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39438     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceQuerySubmitInfoKHR39439     pub fn build(self) -> PerformanceQuerySubmitInfoKHR {
39440         self.inner
39441     }
39442 }
39443 #[repr(C)]
39444 #[derive(Copy, Clone, Debug)]
39445 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html>"]
39446 pub struct HeadlessSurfaceCreateInfoEXT {
39447     pub s_type: StructureType,
39448     pub p_next: *const c_void,
39449     pub flags: HeadlessSurfaceCreateFlagsEXT,
39450 }
39451 impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT {
default() -> HeadlessSurfaceCreateInfoEXT39452     fn default() -> HeadlessSurfaceCreateInfoEXT {
39453         HeadlessSurfaceCreateInfoEXT {
39454             s_type: StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT,
39455             p_next: ::std::ptr::null(),
39456             flags: HeadlessSurfaceCreateFlagsEXT::default(),
39457         }
39458     }
39459 }
39460 impl HeadlessSurfaceCreateInfoEXT {
builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a>39461     pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
39462         HeadlessSurfaceCreateInfoEXTBuilder {
39463             inner: HeadlessSurfaceCreateInfoEXT::default(),
39464             marker: ::std::marker::PhantomData,
39465         }
39466     }
39467 }
39468 #[repr(transparent)]
39469 pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> {
39470     inner: HeadlessSurfaceCreateInfoEXT,
39471     marker: ::std::marker::PhantomData<&'a ()>,
39472 }
39473 pub unsafe trait ExtendsHeadlessSurfaceCreateInfoEXT {}
39474 impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
39475     type Target = HeadlessSurfaceCreateInfoEXT;
deref(&self) -> &Self::Target39476     fn deref(&self) -> &Self::Target {
39477         &self.inner
39478     }
39479 }
39480 impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39481     fn deref_mut(&mut self) -> &mut Self::Target {
39482         &mut self.inner
39483     }
39484 }
39485 impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
flags( mut self, flags: HeadlessSurfaceCreateFlagsEXT, ) -> HeadlessSurfaceCreateInfoEXTBuilder<'a>39486     pub fn flags(
39487         mut self,
39488         flags: HeadlessSurfaceCreateFlagsEXT,
39489     ) -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
39490         self.inner.flags = flags;
39491         self
39492     }
39493     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
39494     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
39495     #[doc = r" valid extension structs can be pushed into the chain."]
39496     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
39497     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsHeadlessSurfaceCreateInfoEXT>( mut self, next: &'a mut T, ) -> HeadlessSurfaceCreateInfoEXTBuilder<'a>39498     pub fn push_next<T: ExtendsHeadlessSurfaceCreateInfoEXT>(
39499         mut self,
39500         next: &'a mut T,
39501     ) -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
39502         unsafe {
39503             let next_ptr = next as *mut T as *mut BaseOutStructure;
39504             let last_next = ptr_chain_iter(next).last().unwrap();
39505             (*last_next).p_next = self.inner.p_next as _;
39506             self.inner.p_next = next_ptr as _;
39507         }
39508         self
39509     }
39510     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39511     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39512     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> HeadlessSurfaceCreateInfoEXT39513     pub fn build(self) -> HeadlessSurfaceCreateInfoEXT {
39514         self.inner
39515     }
39516 }
39517 #[repr(C)]
39518 #[derive(Copy, Clone, Debug)]
39519 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>"]
39520 pub struct PhysicalDeviceCoverageReductionModeFeaturesNV {
39521     pub s_type: StructureType,
39522     pub p_next: *mut c_void,
39523     pub coverage_reduction_mode: Bool32,
39524 }
39525 impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV {
default() -> PhysicalDeviceCoverageReductionModeFeaturesNV39526     fn default() -> PhysicalDeviceCoverageReductionModeFeaturesNV {
39527         PhysicalDeviceCoverageReductionModeFeaturesNV {
39528             s_type: StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
39529             p_next: ::std::ptr::null_mut(),
39530             coverage_reduction_mode: Bool32::default(),
39531         }
39532     }
39533 }
39534 impl PhysicalDeviceCoverageReductionModeFeaturesNV {
builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a>39535     pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
39536         PhysicalDeviceCoverageReductionModeFeaturesNVBuilder {
39537             inner: PhysicalDeviceCoverageReductionModeFeaturesNV::default(),
39538             marker: ::std::marker::PhantomData,
39539         }
39540     }
39541 }
39542 #[repr(transparent)]
39543 pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
39544     inner: PhysicalDeviceCoverageReductionModeFeaturesNV,
39545     marker: ::std::marker::PhantomData<&'a ()>,
39546 }
39547 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {}
39548 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {}
39549 impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
39550     type Target = PhysicalDeviceCoverageReductionModeFeaturesNV;
deref(&self) -> &Self::Target39551     fn deref(&self) -> &Self::Target {
39552         &self.inner
39553     }
39554 }
39555 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39556     fn deref_mut(&mut self) -> &mut Self::Target {
39557         &mut self.inner
39558     }
39559 }
39560 impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
coverage_reduction_mode( mut self, coverage_reduction_mode: bool, ) -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a>39561     pub fn coverage_reduction_mode(
39562         mut self,
39563         coverage_reduction_mode: bool,
39564     ) -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
39565         self.inner.coverage_reduction_mode = coverage_reduction_mode.into();
39566         self
39567     }
39568     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39569     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39570     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV39571     pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV {
39572         self.inner
39573     }
39574 }
39575 #[repr(C)]
39576 #[derive(Copy, Clone, Debug)]
39577 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>"]
39578 pub struct PipelineCoverageReductionStateCreateInfoNV {
39579     pub s_type: StructureType,
39580     pub p_next: *const c_void,
39581     pub flags: PipelineCoverageReductionStateCreateFlagsNV,
39582     pub coverage_reduction_mode: CoverageReductionModeNV,
39583 }
39584 impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV {
default() -> PipelineCoverageReductionStateCreateInfoNV39585     fn default() -> PipelineCoverageReductionStateCreateInfoNV {
39586         PipelineCoverageReductionStateCreateInfoNV {
39587             s_type: StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
39588             p_next: ::std::ptr::null(),
39589             flags: PipelineCoverageReductionStateCreateFlagsNV::default(),
39590             coverage_reduction_mode: CoverageReductionModeNV::default(),
39591         }
39592     }
39593 }
39594 impl PipelineCoverageReductionStateCreateInfoNV {
builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a>39595     pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
39596         PipelineCoverageReductionStateCreateInfoNVBuilder {
39597             inner: PipelineCoverageReductionStateCreateInfoNV::default(),
39598             marker: ::std::marker::PhantomData,
39599         }
39600     }
39601 }
39602 #[repr(transparent)]
39603 pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
39604     inner: PipelineCoverageReductionStateCreateInfoNV,
39605     marker: ::std::marker::PhantomData<&'a ()>,
39606 }
39607 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
39608     for PipelineCoverageReductionStateCreateInfoNVBuilder<'_>
39609 {
39610 }
39611 unsafe impl ExtendsPipelineMultisampleStateCreateInfo
39612     for PipelineCoverageReductionStateCreateInfoNV
39613 {
39614 }
39615 impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
39616     type Target = PipelineCoverageReductionStateCreateInfoNV;
deref(&self) -> &Self::Target39617     fn deref(&self) -> &Self::Target {
39618         &self.inner
39619     }
39620 }
39621 impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39622     fn deref_mut(&mut self) -> &mut Self::Target {
39623         &mut self.inner
39624     }
39625 }
39626 impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
flags( mut self, flags: PipelineCoverageReductionStateCreateFlagsNV, ) -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a>39627     pub fn flags(
39628         mut self,
39629         flags: PipelineCoverageReductionStateCreateFlagsNV,
39630     ) -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
39631         self.inner.flags = flags;
39632         self
39633     }
coverage_reduction_mode( mut self, coverage_reduction_mode: CoverageReductionModeNV, ) -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a>39634     pub fn coverage_reduction_mode(
39635         mut self,
39636         coverage_reduction_mode: CoverageReductionModeNV,
39637     ) -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
39638         self.inner.coverage_reduction_mode = coverage_reduction_mode;
39639         self
39640     }
39641     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39642     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39643     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCoverageReductionStateCreateInfoNV39644     pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV {
39645         self.inner
39646     }
39647 }
39648 #[repr(C)]
39649 #[derive(Copy, Clone, Debug)]
39650 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html>"]
39651 pub struct FramebufferMixedSamplesCombinationNV {
39652     pub s_type: StructureType,
39653     pub p_next: *mut c_void,
39654     pub coverage_reduction_mode: CoverageReductionModeNV,
39655     pub rasterization_samples: SampleCountFlags,
39656     pub depth_stencil_samples: SampleCountFlags,
39657     pub color_samples: SampleCountFlags,
39658 }
39659 impl ::std::default::Default for FramebufferMixedSamplesCombinationNV {
default() -> FramebufferMixedSamplesCombinationNV39660     fn default() -> FramebufferMixedSamplesCombinationNV {
39661         FramebufferMixedSamplesCombinationNV {
39662             s_type: StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
39663             p_next: ::std::ptr::null_mut(),
39664             coverage_reduction_mode: CoverageReductionModeNV::default(),
39665             rasterization_samples: SampleCountFlags::default(),
39666             depth_stencil_samples: SampleCountFlags::default(),
39667             color_samples: SampleCountFlags::default(),
39668         }
39669     }
39670 }
39671 impl FramebufferMixedSamplesCombinationNV {
builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a>39672     pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
39673         FramebufferMixedSamplesCombinationNVBuilder {
39674             inner: FramebufferMixedSamplesCombinationNV::default(),
39675             marker: ::std::marker::PhantomData,
39676         }
39677     }
39678 }
39679 #[repr(transparent)]
39680 pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> {
39681     inner: FramebufferMixedSamplesCombinationNV,
39682     marker: ::std::marker::PhantomData<&'a ()>,
39683 }
39684 pub unsafe trait ExtendsFramebufferMixedSamplesCombinationNV {}
39685 impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> {
39686     type Target = FramebufferMixedSamplesCombinationNV;
deref(&self) -> &Self::Target39687     fn deref(&self) -> &Self::Target {
39688         &self.inner
39689     }
39690 }
39691 impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39692     fn deref_mut(&mut self) -> &mut Self::Target {
39693         &mut self.inner
39694     }
39695 }
39696 impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
coverage_reduction_mode( mut self, coverage_reduction_mode: CoverageReductionModeNV, ) -> FramebufferMixedSamplesCombinationNVBuilder<'a>39697     pub fn coverage_reduction_mode(
39698         mut self,
39699         coverage_reduction_mode: CoverageReductionModeNV,
39700     ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
39701         self.inner.coverage_reduction_mode = coverage_reduction_mode;
39702         self
39703     }
rasterization_samples( mut self, rasterization_samples: SampleCountFlags, ) -> FramebufferMixedSamplesCombinationNVBuilder<'a>39704     pub fn rasterization_samples(
39705         mut self,
39706         rasterization_samples: SampleCountFlags,
39707     ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
39708         self.inner.rasterization_samples = rasterization_samples;
39709         self
39710     }
depth_stencil_samples( mut self, depth_stencil_samples: SampleCountFlags, ) -> FramebufferMixedSamplesCombinationNVBuilder<'a>39711     pub fn depth_stencil_samples(
39712         mut self,
39713         depth_stencil_samples: SampleCountFlags,
39714     ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
39715         self.inner.depth_stencil_samples = depth_stencil_samples;
39716         self
39717     }
color_samples( mut self, color_samples: SampleCountFlags, ) -> FramebufferMixedSamplesCombinationNVBuilder<'a>39718     pub fn color_samples(
39719         mut self,
39720         color_samples: SampleCountFlags,
39721     ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
39722         self.inner.color_samples = color_samples;
39723         self
39724     }
39725     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
39726     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
39727     #[doc = r" valid extension structs can be pushed into the chain."]
39728     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
39729     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsFramebufferMixedSamplesCombinationNV>( mut self, next: &'a mut T, ) -> FramebufferMixedSamplesCombinationNVBuilder<'a>39730     pub fn push_next<T: ExtendsFramebufferMixedSamplesCombinationNV>(
39731         mut self,
39732         next: &'a mut T,
39733     ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
39734         unsafe {
39735             let next_ptr = next as *mut T as *mut BaseOutStructure;
39736             let last_next = ptr_chain_iter(next).last().unwrap();
39737             (*last_next).p_next = self.inner.p_next as _;
39738             self.inner.p_next = next_ptr as _;
39739         }
39740         self
39741     }
39742     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39743     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39744     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FramebufferMixedSamplesCombinationNV39745     pub fn build(self) -> FramebufferMixedSamplesCombinationNV {
39746         self.inner
39747     }
39748 }
39749 #[repr(C)]
39750 #[derive(Copy, Clone, Debug)]
39751 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>"]
39752 pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
39753     pub s_type: StructureType,
39754     pub p_next: *mut c_void,
39755     pub shader_integer_functions2: Bool32,
39756 }
39757 impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
default() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL39758     fn default() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
39759         PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
39760             s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
39761             p_next: ::std::ptr::null_mut(),
39762             shader_integer_functions2: Bool32::default(),
39763         }
39764     }
39765 }
39766 impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a>39767     pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
39768         PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder {
39769             inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::default(),
39770             marker: ::std::marker::PhantomData,
39771         }
39772     }
39773 }
39774 #[repr(transparent)]
39775 pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
39776     inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
39777     marker: ::std::marker::PhantomData<&'a ()>,
39778 }
39779 unsafe impl ExtendsDeviceCreateInfo
39780     for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
39781 {
39782 }
39783 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
39784 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
39785     type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
deref(&self) -> &Self::Target39786     fn deref(&self) -> &Self::Target {
39787         &self.inner
39788     }
39789 }
39790 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39791     fn deref_mut(&mut self) -> &mut Self::Target {
39792         &mut self.inner
39793     }
39794 }
39795 impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
shader_integer_functions2( mut self, shader_integer_functions2: bool, ) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a>39796     pub fn shader_integer_functions2(
39797         mut self,
39798         shader_integer_functions2: bool,
39799     ) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
39800         self.inner.shader_integer_functions2 = shader_integer_functions2.into();
39801         self
39802     }
39803     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39804     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39805     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL39806     pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
39807         self.inner
39808     }
39809 }
39810 #[repr(C)]
39811 #[derive(Copy, Clone)]
39812 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceValueDataINTEL.html>"]
39813 pub union PerformanceValueDataINTEL {
39814     pub value32: u32,
39815     pub value64: u64,
39816     pub value_float: f32,
39817     pub value_bool: Bool32,
39818     pub value_string: *const c_char,
39819 }
39820 impl ::std::default::Default for PerformanceValueDataINTEL {
default() -> PerformanceValueDataINTEL39821     fn default() -> PerformanceValueDataINTEL {
39822         unsafe { ::std::mem::zeroed() }
39823     }
39824 }
39825 #[repr(C)]
39826 #[derive(Copy, Clone, Default)]
39827 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceValueINTEL.html>"]
39828 pub struct PerformanceValueINTEL {
39829     pub ty: PerformanceValueTypeINTEL,
39830     pub data: PerformanceValueDataINTEL,
39831 }
39832 impl fmt::Debug for PerformanceValueINTEL {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result39833     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
39834         fmt.debug_struct("PerformanceValueINTEL")
39835             .field("ty", &self.ty)
39836             .field("data", &"union")
39837             .finish()
39838     }
39839 }
39840 impl PerformanceValueINTEL {
builder<'a>() -> PerformanceValueINTELBuilder<'a>39841     pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> {
39842         PerformanceValueINTELBuilder {
39843             inner: PerformanceValueINTEL::default(),
39844             marker: ::std::marker::PhantomData,
39845         }
39846     }
39847 }
39848 #[repr(transparent)]
39849 pub struct PerformanceValueINTELBuilder<'a> {
39850     inner: PerformanceValueINTEL,
39851     marker: ::std::marker::PhantomData<&'a ()>,
39852 }
39853 impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> {
39854     type Target = PerformanceValueINTEL;
deref(&self) -> &Self::Target39855     fn deref(&self) -> &Self::Target {
39856         &self.inner
39857     }
39858 }
39859 impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39860     fn deref_mut(&mut self) -> &mut Self::Target {
39861         &mut self.inner
39862     }
39863 }
39864 impl<'a> PerformanceValueINTELBuilder<'a> {
ty(mut self, ty: PerformanceValueTypeINTEL) -> PerformanceValueINTELBuilder<'a>39865     pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> PerformanceValueINTELBuilder<'a> {
39866         self.inner.ty = ty;
39867         self
39868     }
data(mut self, data: PerformanceValueDataINTEL) -> PerformanceValueINTELBuilder<'a>39869     pub fn data(mut self, data: PerformanceValueDataINTEL) -> PerformanceValueINTELBuilder<'a> {
39870         self.inner.data = data;
39871         self
39872     }
39873     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39874     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39875     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceValueINTEL39876     pub fn build(self) -> PerformanceValueINTEL {
39877         self.inner
39878     }
39879 }
39880 #[repr(C)]
39881 #[derive(Copy, Clone, Debug)]
39882 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html>"]
39883 pub struct InitializePerformanceApiInfoINTEL {
39884     pub s_type: StructureType,
39885     pub p_next: *const c_void,
39886     pub p_user_data: *mut c_void,
39887 }
39888 impl ::std::default::Default for InitializePerformanceApiInfoINTEL {
default() -> InitializePerformanceApiInfoINTEL39889     fn default() -> InitializePerformanceApiInfoINTEL {
39890         InitializePerformanceApiInfoINTEL {
39891             s_type: StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL,
39892             p_next: ::std::ptr::null(),
39893             p_user_data: ::std::ptr::null_mut(),
39894         }
39895     }
39896 }
39897 impl InitializePerformanceApiInfoINTEL {
builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a>39898     pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> {
39899         InitializePerformanceApiInfoINTELBuilder {
39900             inner: InitializePerformanceApiInfoINTEL::default(),
39901             marker: ::std::marker::PhantomData,
39902         }
39903     }
39904 }
39905 #[repr(transparent)]
39906 pub struct InitializePerformanceApiInfoINTELBuilder<'a> {
39907     inner: InitializePerformanceApiInfoINTEL,
39908     marker: ::std::marker::PhantomData<&'a ()>,
39909 }
39910 pub unsafe trait ExtendsInitializePerformanceApiInfoINTEL {}
39911 impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> {
39912     type Target = InitializePerformanceApiInfoINTEL;
deref(&self) -> &Self::Target39913     fn deref(&self) -> &Self::Target {
39914         &self.inner
39915     }
39916 }
39917 impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39918     fn deref_mut(&mut self) -> &mut Self::Target {
39919         &mut self.inner
39920     }
39921 }
39922 impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
user_data( mut self, user_data: *mut c_void, ) -> InitializePerformanceApiInfoINTELBuilder<'a>39923     pub fn user_data(
39924         mut self,
39925         user_data: *mut c_void,
39926     ) -> InitializePerformanceApiInfoINTELBuilder<'a> {
39927         self.inner.p_user_data = user_data;
39928         self
39929     }
39930     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
39931     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
39932     #[doc = r" valid extension structs can be pushed into the chain."]
39933     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
39934     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsInitializePerformanceApiInfoINTEL>( mut self, next: &'a mut T, ) -> InitializePerformanceApiInfoINTELBuilder<'a>39935     pub fn push_next<T: ExtendsInitializePerformanceApiInfoINTEL>(
39936         mut self,
39937         next: &'a mut T,
39938     ) -> InitializePerformanceApiInfoINTELBuilder<'a> {
39939         unsafe {
39940             let next_ptr = next as *mut T as *mut BaseOutStructure;
39941             let last_next = ptr_chain_iter(next).last().unwrap();
39942             (*last_next).p_next = self.inner.p_next as _;
39943             self.inner.p_next = next_ptr as _;
39944         }
39945         self
39946     }
39947     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
39948     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
39949     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> InitializePerformanceApiInfoINTEL39950     pub fn build(self) -> InitializePerformanceApiInfoINTEL {
39951         self.inner
39952     }
39953 }
39954 #[repr(C)]
39955 #[derive(Copy, Clone, Debug)]
39956 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>"]
39957 pub struct QueryPoolPerformanceQueryCreateInfoINTEL {
39958     pub s_type: StructureType,
39959     pub p_next: *const c_void,
39960     pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
39961 }
39962 impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL {
default() -> QueryPoolPerformanceQueryCreateInfoINTEL39963     fn default() -> QueryPoolPerformanceQueryCreateInfoINTEL {
39964         QueryPoolPerformanceQueryCreateInfoINTEL {
39965             s_type: StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
39966             p_next: ::std::ptr::null(),
39967             performance_counters_sampling: QueryPoolSamplingModeINTEL::default(),
39968         }
39969     }
39970 }
39971 impl QueryPoolPerformanceQueryCreateInfoINTEL {
builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a>39972     pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
39973         QueryPoolPerformanceQueryCreateInfoINTELBuilder {
39974             inner: QueryPoolPerformanceQueryCreateInfoINTEL::default(),
39975             marker: ::std::marker::PhantomData,
39976         }
39977     }
39978 }
39979 #[repr(transparent)]
39980 pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
39981     inner: QueryPoolPerformanceQueryCreateInfoINTEL,
39982     marker: ::std::marker::PhantomData<&'a ()>,
39983 }
39984 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {}
39985 unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {}
39986 impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
39987     type Target = QueryPoolPerformanceQueryCreateInfoINTEL;
deref(&self) -> &Self::Target39988     fn deref(&self) -> &Self::Target {
39989         &self.inner
39990     }
39991 }
39992 impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target39993     fn deref_mut(&mut self) -> &mut Self::Target {
39994         &mut self.inner
39995     }
39996 }
39997 impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
performance_counters_sampling( mut self, performance_counters_sampling: QueryPoolSamplingModeINTEL, ) -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a>39998     pub fn performance_counters_sampling(
39999         mut self,
40000         performance_counters_sampling: QueryPoolSamplingModeINTEL,
40001     ) -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
40002         self.inner.performance_counters_sampling = performance_counters_sampling;
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."]
build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL40008     pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL {
40009         self.inner
40010     }
40011 }
40012 #[repr(C)]
40013 #[derive(Copy, Clone, Debug)]
40014 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceMarkerInfoINTEL.html>"]
40015 pub struct PerformanceMarkerInfoINTEL {
40016     pub s_type: StructureType,
40017     pub p_next: *const c_void,
40018     pub marker: u64,
40019 }
40020 impl ::std::default::Default for PerformanceMarkerInfoINTEL {
default() -> PerformanceMarkerInfoINTEL40021     fn default() -> PerformanceMarkerInfoINTEL {
40022         PerformanceMarkerInfoINTEL {
40023             s_type: StructureType::PERFORMANCE_MARKER_INFO_INTEL,
40024             p_next: ::std::ptr::null(),
40025             marker: u64::default(),
40026         }
40027     }
40028 }
40029 impl PerformanceMarkerInfoINTEL {
builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a>40030     pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> {
40031         PerformanceMarkerInfoINTELBuilder {
40032             inner: PerformanceMarkerInfoINTEL::default(),
40033             marker: ::std::marker::PhantomData,
40034         }
40035     }
40036 }
40037 #[repr(transparent)]
40038 pub struct PerformanceMarkerInfoINTELBuilder<'a> {
40039     inner: PerformanceMarkerInfoINTEL,
40040     marker: ::std::marker::PhantomData<&'a ()>,
40041 }
40042 pub unsafe trait ExtendsPerformanceMarkerInfoINTEL {}
40043 impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> {
40044     type Target = PerformanceMarkerInfoINTEL;
deref(&self) -> &Self::Target40045     fn deref(&self) -> &Self::Target {
40046         &self.inner
40047     }
40048 }
40049 impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40050     fn deref_mut(&mut self) -> &mut Self::Target {
40051         &mut self.inner
40052     }
40053 }
40054 impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
marker(mut self, marker: u64) -> PerformanceMarkerInfoINTELBuilder<'a>40055     pub fn marker(mut self, marker: u64) -> PerformanceMarkerInfoINTELBuilder<'a> {
40056         self.inner.marker = marker;
40057         self
40058     }
40059     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
40060     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
40061     #[doc = r" valid extension structs can be pushed into the chain."]
40062     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
40063     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPerformanceMarkerInfoINTEL>( mut self, next: &'a mut T, ) -> PerformanceMarkerInfoINTELBuilder<'a>40064     pub fn push_next<T: ExtendsPerformanceMarkerInfoINTEL>(
40065         mut self,
40066         next: &'a mut T,
40067     ) -> PerformanceMarkerInfoINTELBuilder<'a> {
40068         unsafe {
40069             let next_ptr = next as *mut T as *mut BaseOutStructure;
40070             let last_next = ptr_chain_iter(next).last().unwrap();
40071             (*last_next).p_next = self.inner.p_next as _;
40072             self.inner.p_next = next_ptr as _;
40073         }
40074         self
40075     }
40076     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40077     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40078     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceMarkerInfoINTEL40079     pub fn build(self) -> PerformanceMarkerInfoINTEL {
40080         self.inner
40081     }
40082 }
40083 #[repr(C)]
40084 #[derive(Copy, Clone, Debug)]
40085 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html>"]
40086 pub struct PerformanceStreamMarkerInfoINTEL {
40087     pub s_type: StructureType,
40088     pub p_next: *const c_void,
40089     pub marker: u32,
40090 }
40091 impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL {
default() -> PerformanceStreamMarkerInfoINTEL40092     fn default() -> PerformanceStreamMarkerInfoINTEL {
40093         PerformanceStreamMarkerInfoINTEL {
40094             s_type: StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL,
40095             p_next: ::std::ptr::null(),
40096             marker: u32::default(),
40097         }
40098     }
40099 }
40100 impl PerformanceStreamMarkerInfoINTEL {
builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a>40101     pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
40102         PerformanceStreamMarkerInfoINTELBuilder {
40103             inner: PerformanceStreamMarkerInfoINTEL::default(),
40104             marker: ::std::marker::PhantomData,
40105         }
40106     }
40107 }
40108 #[repr(transparent)]
40109 pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> {
40110     inner: PerformanceStreamMarkerInfoINTEL,
40111     marker: ::std::marker::PhantomData<&'a ()>,
40112 }
40113 pub unsafe trait ExtendsPerformanceStreamMarkerInfoINTEL {}
40114 impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> {
40115     type Target = PerformanceStreamMarkerInfoINTEL;
deref(&self) -> &Self::Target40116     fn deref(&self) -> &Self::Target {
40117         &self.inner
40118     }
40119 }
40120 impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40121     fn deref_mut(&mut self) -> &mut Self::Target {
40122         &mut self.inner
40123     }
40124 }
40125 impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
marker(mut self, marker: u32) -> PerformanceStreamMarkerInfoINTELBuilder<'a>40126     pub fn marker(mut self, marker: u32) -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
40127         self.inner.marker = marker;
40128         self
40129     }
40130     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
40131     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
40132     #[doc = r" valid extension structs can be pushed into the chain."]
40133     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
40134     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPerformanceStreamMarkerInfoINTEL>( mut self, next: &'a mut T, ) -> PerformanceStreamMarkerInfoINTELBuilder<'a>40135     pub fn push_next<T: ExtendsPerformanceStreamMarkerInfoINTEL>(
40136         mut self,
40137         next: &'a mut T,
40138     ) -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
40139         unsafe {
40140             let next_ptr = next as *mut T as *mut BaseOutStructure;
40141             let last_next = ptr_chain_iter(next).last().unwrap();
40142             (*last_next).p_next = self.inner.p_next as _;
40143             self.inner.p_next = next_ptr as _;
40144         }
40145         self
40146     }
40147     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40148     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40149     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceStreamMarkerInfoINTEL40150     pub fn build(self) -> PerformanceStreamMarkerInfoINTEL {
40151         self.inner
40152     }
40153 }
40154 #[repr(C)]
40155 #[derive(Copy, Clone, Debug)]
40156 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceOverrideInfoINTEL.html>"]
40157 pub struct PerformanceOverrideInfoINTEL {
40158     pub s_type: StructureType,
40159     pub p_next: *const c_void,
40160     pub ty: PerformanceOverrideTypeINTEL,
40161     pub enable: Bool32,
40162     pub parameter: u64,
40163 }
40164 impl ::std::default::Default for PerformanceOverrideInfoINTEL {
default() -> PerformanceOverrideInfoINTEL40165     fn default() -> PerformanceOverrideInfoINTEL {
40166         PerformanceOverrideInfoINTEL {
40167             s_type: StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL,
40168             p_next: ::std::ptr::null(),
40169             ty: PerformanceOverrideTypeINTEL::default(),
40170             enable: Bool32::default(),
40171             parameter: u64::default(),
40172         }
40173     }
40174 }
40175 impl PerformanceOverrideInfoINTEL {
builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a>40176     pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> {
40177         PerformanceOverrideInfoINTELBuilder {
40178             inner: PerformanceOverrideInfoINTEL::default(),
40179             marker: ::std::marker::PhantomData,
40180         }
40181     }
40182 }
40183 #[repr(transparent)]
40184 pub struct PerformanceOverrideInfoINTELBuilder<'a> {
40185     inner: PerformanceOverrideInfoINTEL,
40186     marker: ::std::marker::PhantomData<&'a ()>,
40187 }
40188 pub unsafe trait ExtendsPerformanceOverrideInfoINTEL {}
40189 impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> {
40190     type Target = PerformanceOverrideInfoINTEL;
deref(&self) -> &Self::Target40191     fn deref(&self) -> &Self::Target {
40192         &self.inner
40193     }
40194 }
40195 impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40196     fn deref_mut(&mut self) -> &mut Self::Target {
40197         &mut self.inner
40198     }
40199 }
40200 impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
ty( mut self, ty: PerformanceOverrideTypeINTEL, ) -> PerformanceOverrideInfoINTELBuilder<'a>40201     pub fn ty(
40202         mut self,
40203         ty: PerformanceOverrideTypeINTEL,
40204     ) -> PerformanceOverrideInfoINTELBuilder<'a> {
40205         self.inner.ty = ty;
40206         self
40207     }
enable(mut self, enable: bool) -> PerformanceOverrideInfoINTELBuilder<'a>40208     pub fn enable(mut self, enable: bool) -> PerformanceOverrideInfoINTELBuilder<'a> {
40209         self.inner.enable = enable.into();
40210         self
40211     }
parameter(mut self, parameter: u64) -> PerformanceOverrideInfoINTELBuilder<'a>40212     pub fn parameter(mut self, parameter: u64) -> PerformanceOverrideInfoINTELBuilder<'a> {
40213         self.inner.parameter = parameter;
40214         self
40215     }
40216     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
40217     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
40218     #[doc = r" valid extension structs can be pushed into the chain."]
40219     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
40220     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPerformanceOverrideInfoINTEL>( mut self, next: &'a mut T, ) -> PerformanceOverrideInfoINTELBuilder<'a>40221     pub fn push_next<T: ExtendsPerformanceOverrideInfoINTEL>(
40222         mut self,
40223         next: &'a mut T,
40224     ) -> PerformanceOverrideInfoINTELBuilder<'a> {
40225         unsafe {
40226             let next_ptr = next as *mut T as *mut BaseOutStructure;
40227             let last_next = ptr_chain_iter(next).last().unwrap();
40228             (*last_next).p_next = self.inner.p_next as _;
40229             self.inner.p_next = next_ptr as _;
40230         }
40231         self
40232     }
40233     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40234     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40235     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceOverrideInfoINTEL40236     pub fn build(self) -> PerformanceOverrideInfoINTEL {
40237         self.inner
40238     }
40239 }
40240 #[repr(C)]
40241 #[derive(Copy, Clone, Debug)]
40242 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>"]
40243 pub struct PerformanceConfigurationAcquireInfoINTEL {
40244     pub s_type: StructureType,
40245     pub p_next: *const c_void,
40246     pub ty: PerformanceConfigurationTypeINTEL,
40247 }
40248 impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL {
default() -> PerformanceConfigurationAcquireInfoINTEL40249     fn default() -> PerformanceConfigurationAcquireInfoINTEL {
40250         PerformanceConfigurationAcquireInfoINTEL {
40251             s_type: StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
40252             p_next: ::std::ptr::null(),
40253             ty: PerformanceConfigurationTypeINTEL::default(),
40254         }
40255     }
40256 }
40257 impl PerformanceConfigurationAcquireInfoINTEL {
builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a>40258     pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
40259         PerformanceConfigurationAcquireInfoINTELBuilder {
40260             inner: PerformanceConfigurationAcquireInfoINTEL::default(),
40261             marker: ::std::marker::PhantomData,
40262         }
40263     }
40264 }
40265 #[repr(transparent)]
40266 pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
40267     inner: PerformanceConfigurationAcquireInfoINTEL,
40268     marker: ::std::marker::PhantomData<&'a ()>,
40269 }
40270 pub unsafe trait ExtendsPerformanceConfigurationAcquireInfoINTEL {}
40271 impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
40272     type Target = PerformanceConfigurationAcquireInfoINTEL;
deref(&self) -> &Self::Target40273     fn deref(&self) -> &Self::Target {
40274         &self.inner
40275     }
40276 }
40277 impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40278     fn deref_mut(&mut self) -> &mut Self::Target {
40279         &mut self.inner
40280     }
40281 }
40282 impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
ty( mut self, ty: PerformanceConfigurationTypeINTEL, ) -> PerformanceConfigurationAcquireInfoINTELBuilder<'a>40283     pub fn ty(
40284         mut self,
40285         ty: PerformanceConfigurationTypeINTEL,
40286     ) -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
40287         self.inner.ty = ty;
40288         self
40289     }
40290     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
40291     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
40292     #[doc = r" valid extension structs can be pushed into the chain."]
40293     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
40294     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPerformanceConfigurationAcquireInfoINTEL>( mut self, next: &'a mut T, ) -> PerformanceConfigurationAcquireInfoINTELBuilder<'a>40295     pub fn push_next<T: ExtendsPerformanceConfigurationAcquireInfoINTEL>(
40296         mut self,
40297         next: &'a mut T,
40298     ) -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
40299         unsafe {
40300             let next_ptr = next as *mut T as *mut BaseOutStructure;
40301             let last_next = ptr_chain_iter(next).last().unwrap();
40302             (*last_next).p_next = self.inner.p_next as _;
40303             self.inner.p_next = next_ptr as _;
40304         }
40305         self
40306     }
40307     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40308     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40309     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PerformanceConfigurationAcquireInfoINTEL40310     pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL {
40311         self.inner
40312     }
40313 }
40314 #[repr(C)]
40315 #[derive(Copy, Clone, Debug)]
40316 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>"]
40317 pub struct PhysicalDeviceShaderClockFeaturesKHR {
40318     pub s_type: StructureType,
40319     pub p_next: *mut c_void,
40320     pub shader_subgroup_clock: Bool32,
40321     pub shader_device_clock: Bool32,
40322 }
40323 impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR {
default() -> PhysicalDeviceShaderClockFeaturesKHR40324     fn default() -> PhysicalDeviceShaderClockFeaturesKHR {
40325         PhysicalDeviceShaderClockFeaturesKHR {
40326             s_type: StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
40327             p_next: ::std::ptr::null_mut(),
40328             shader_subgroup_clock: Bool32::default(),
40329             shader_device_clock: Bool32::default(),
40330         }
40331     }
40332 }
40333 impl PhysicalDeviceShaderClockFeaturesKHR {
builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a>40334     pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
40335         PhysicalDeviceShaderClockFeaturesKHRBuilder {
40336             inner: PhysicalDeviceShaderClockFeaturesKHR::default(),
40337             marker: ::std::marker::PhantomData,
40338         }
40339     }
40340 }
40341 #[repr(transparent)]
40342 pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
40343     inner: PhysicalDeviceShaderClockFeaturesKHR,
40344     marker: ::std::marker::PhantomData<&'a ()>,
40345 }
40346 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
40347 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {}
40348 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
40349     type Target = PhysicalDeviceShaderClockFeaturesKHR;
deref(&self) -> &Self::Target40350     fn deref(&self) -> &Self::Target {
40351         &self.inner
40352     }
40353 }
40354 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40355     fn deref_mut(&mut self) -> &mut Self::Target {
40356         &mut self.inner
40357     }
40358 }
40359 impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
shader_subgroup_clock( mut self, shader_subgroup_clock: bool, ) -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a>40360     pub fn shader_subgroup_clock(
40361         mut self,
40362         shader_subgroup_clock: bool,
40363     ) -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
40364         self.inner.shader_subgroup_clock = shader_subgroup_clock.into();
40365         self
40366     }
shader_device_clock( mut self, shader_device_clock: bool, ) -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a>40367     pub fn shader_device_clock(
40368         mut self,
40369         shader_device_clock: bool,
40370     ) -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
40371         self.inner.shader_device_clock = shader_device_clock.into();
40372         self
40373     }
40374     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40375     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40376     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderClockFeaturesKHR40377     pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR {
40378         self.inner
40379     }
40380 }
40381 #[repr(C)]
40382 #[derive(Copy, Clone, Debug)]
40383 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>"]
40384 pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT {
40385     pub s_type: StructureType,
40386     pub p_next: *mut c_void,
40387     pub index_type_uint8: Bool32,
40388 }
40389 impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT {
default() -> PhysicalDeviceIndexTypeUint8FeaturesEXT40390     fn default() -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
40391         PhysicalDeviceIndexTypeUint8FeaturesEXT {
40392             s_type: StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
40393             p_next: ::std::ptr::null_mut(),
40394             index_type_uint8: Bool32::default(),
40395         }
40396     }
40397 }
40398 impl PhysicalDeviceIndexTypeUint8FeaturesEXT {
builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a>40399     pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
40400         PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder {
40401             inner: PhysicalDeviceIndexTypeUint8FeaturesEXT::default(),
40402             marker: ::std::marker::PhantomData,
40403         }
40404     }
40405 }
40406 #[repr(transparent)]
40407 pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
40408     inner: PhysicalDeviceIndexTypeUint8FeaturesEXT,
40409     marker: ::std::marker::PhantomData<&'a ()>,
40410 }
40411 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
40412 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
40413 impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
40414     type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT;
deref(&self) -> &Self::Target40415     fn deref(&self) -> &Self::Target {
40416         &self.inner
40417     }
40418 }
40419 impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40420     fn deref_mut(&mut self) -> &mut Self::Target {
40421         &mut self.inner
40422     }
40423 }
40424 impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
index_type_uint8( mut self, index_type_uint8: bool, ) -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a>40425     pub fn index_type_uint8(
40426         mut self,
40427         index_type_uint8: bool,
40428     ) -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
40429         self.inner.index_type_uint8 = index_type_uint8.into();
40430         self
40431     }
40432     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40433     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40434     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT40435     pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
40436         self.inner
40437     }
40438 }
40439 #[repr(C)]
40440 #[derive(Copy, Clone, Debug)]
40441 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>"]
40442 pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
40443     pub s_type: StructureType,
40444     pub p_next: *mut c_void,
40445     pub shader_sm_count: u32,
40446     pub shader_warps_per_sm: u32,
40447 }
40448 impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
default() -> PhysicalDeviceShaderSMBuiltinsPropertiesNV40449     fn default() -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
40450         PhysicalDeviceShaderSMBuiltinsPropertiesNV {
40451             s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
40452             p_next: ::std::ptr::null_mut(),
40453             shader_sm_count: u32::default(),
40454             shader_warps_per_sm: u32::default(),
40455         }
40456     }
40457 }
40458 impl PhysicalDeviceShaderSMBuiltinsPropertiesNV {
builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a>40459     pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
40460         PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder {
40461             inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV::default(),
40462             marker: ::std::marker::PhantomData,
40463         }
40464     }
40465 }
40466 #[repr(transparent)]
40467 pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
40468     inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV,
40469     marker: ::std::marker::PhantomData<&'a ()>,
40470 }
40471 unsafe impl ExtendsPhysicalDeviceProperties2
40472     for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_>
40473 {
40474 }
40475 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {}
40476 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
40477     type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
deref(&self) -> &Self::Target40478     fn deref(&self) -> &Self::Target {
40479         &self.inner
40480     }
40481 }
40482 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40483     fn deref_mut(&mut self) -> &mut Self::Target {
40484         &mut self.inner
40485     }
40486 }
40487 impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
shader_sm_count( mut self, shader_sm_count: u32, ) -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a>40488     pub fn shader_sm_count(
40489         mut self,
40490         shader_sm_count: u32,
40491     ) -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
40492         self.inner.shader_sm_count = shader_sm_count;
40493         self
40494     }
shader_warps_per_sm( mut self, shader_warps_per_sm: u32, ) -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a>40495     pub fn shader_warps_per_sm(
40496         mut self,
40497         shader_warps_per_sm: u32,
40498     ) -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
40499         self.inner.shader_warps_per_sm = shader_warps_per_sm;
40500         self
40501     }
40502     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40503     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40504     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV40505     pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
40506         self.inner
40507     }
40508 }
40509 #[repr(C)]
40510 #[derive(Copy, Clone, Debug)]
40511 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>"]
40512 pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
40513     pub s_type: StructureType,
40514     pub p_next: *mut c_void,
40515     pub shader_sm_builtins: Bool32,
40516 }
40517 impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
default() -> PhysicalDeviceShaderSMBuiltinsFeaturesNV40518     fn default() -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
40519         PhysicalDeviceShaderSMBuiltinsFeaturesNV {
40520             s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
40521             p_next: ::std::ptr::null_mut(),
40522             shader_sm_builtins: Bool32::default(),
40523         }
40524     }
40525 }
40526 impl PhysicalDeviceShaderSMBuiltinsFeaturesNV {
builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a>40527     pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
40528         PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder {
40529             inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV::default(),
40530             marker: ::std::marker::PhantomData,
40531         }
40532     }
40533 }
40534 #[repr(transparent)]
40535 pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
40536     inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV,
40537     marker: ::std::marker::PhantomData<&'a ()>,
40538 }
40539 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
40540 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
40541 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
40542     type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
deref(&self) -> &Self::Target40543     fn deref(&self) -> &Self::Target {
40544         &self.inner
40545     }
40546 }
40547 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40548     fn deref_mut(&mut self) -> &mut Self::Target {
40549         &mut self.inner
40550     }
40551 }
40552 impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
shader_sm_builtins( mut self, shader_sm_builtins: bool, ) -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a>40553     pub fn shader_sm_builtins(
40554         mut self,
40555         shader_sm_builtins: bool,
40556     ) -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
40557         self.inner.shader_sm_builtins = shader_sm_builtins.into();
40558         self
40559     }
40560     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40561     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40562     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV40563     pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
40564         self.inner
40565     }
40566 }
40567 #[repr(C)]
40568 #[derive(Copy, Clone, Debug)]
40569 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>"]
40570 pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
40571     pub s_type: StructureType,
40572     pub p_next: *mut c_void,
40573     pub fragment_shader_sample_interlock: Bool32,
40574     pub fragment_shader_pixel_interlock: Bool32,
40575     pub fragment_shader_shading_rate_interlock: Bool32,
40576 }
40577 impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
default() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT40578     fn default() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
40579         PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
40580             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
40581             p_next: ::std::ptr::null_mut(),
40582             fragment_shader_sample_interlock: Bool32::default(),
40583             fragment_shader_pixel_interlock: Bool32::default(),
40584             fragment_shader_shading_rate_interlock: Bool32::default(),
40585         }
40586     }
40587 }
40588 impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a>40589     pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
40590         PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder {
40591             inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT::default(),
40592             marker: ::std::marker::PhantomData,
40593         }
40594     }
40595 }
40596 #[repr(transparent)]
40597 pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
40598     inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
40599     marker: ::std::marker::PhantomData<&'a ()>,
40600 }
40601 unsafe impl ExtendsDeviceCreateInfo
40602     for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
40603 {
40604 }
40605 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
40606 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
40607     type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
deref(&self) -> &Self::Target40608     fn deref(&self) -> &Self::Target {
40609         &self.inner
40610     }
40611 }
40612 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40613     fn deref_mut(&mut self) -> &mut Self::Target {
40614         &mut self.inner
40615     }
40616 }
40617 impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
fragment_shader_sample_interlock( mut self, fragment_shader_sample_interlock: bool, ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a>40618     pub fn fragment_shader_sample_interlock(
40619         mut self,
40620         fragment_shader_sample_interlock: bool,
40621     ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
40622         self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into();
40623         self
40624     }
fragment_shader_pixel_interlock( mut self, fragment_shader_pixel_interlock: bool, ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a>40625     pub fn fragment_shader_pixel_interlock(
40626         mut self,
40627         fragment_shader_pixel_interlock: bool,
40628     ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
40629         self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into();
40630         self
40631     }
fragment_shader_shading_rate_interlock( mut self, fragment_shader_shading_rate_interlock: bool, ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a>40632     pub fn fragment_shader_shading_rate_interlock(
40633         mut self,
40634         fragment_shader_shading_rate_interlock: bool,
40635     ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
40636         self.inner.fragment_shader_shading_rate_interlock =
40637             fragment_shader_shading_rate_interlock.into();
40638         self
40639     }
40640     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40641     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40642     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT40643     pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
40644         self.inner
40645     }
40646 }
40647 #[repr(C)]
40648 #[derive(Copy, Clone, Debug)]
40649 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>"]
40650 pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
40651     pub s_type: StructureType,
40652     pub p_next: *mut c_void,
40653     pub separate_depth_stencil_layouts: Bool32,
40654 }
40655 impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
default() -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures40656     fn default() -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
40657         PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
40658             s_type: StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
40659             p_next: ::std::ptr::null_mut(),
40660             separate_depth_stencil_layouts: Bool32::default(),
40661         }
40662     }
40663 }
40664 impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a>40665     pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
40666         PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder {
40667             inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures::default(),
40668             marker: ::std::marker::PhantomData,
40669         }
40670     }
40671 }
40672 #[repr(transparent)]
40673 pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
40674     inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
40675     marker: ::std::marker::PhantomData<&'a ()>,
40676 }
40677 unsafe impl ExtendsDeviceCreateInfo
40678     for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
40679 {
40680 }
40681 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
40682 impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
40683     type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
deref(&self) -> &Self::Target40684     fn deref(&self) -> &Self::Target {
40685         &self.inner
40686     }
40687 }
40688 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40689     fn deref_mut(&mut self) -> &mut Self::Target {
40690         &mut self.inner
40691     }
40692 }
40693 impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
separate_depth_stencil_layouts( mut self, separate_depth_stencil_layouts: bool, ) -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a>40694     pub fn separate_depth_stencil_layouts(
40695         mut self,
40696         separate_depth_stencil_layouts: bool,
40697     ) -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
40698         self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
40699         self
40700     }
40701     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40702     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40703     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures40704     pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
40705         self.inner
40706     }
40707 }
40708 #[repr(C)]
40709 #[derive(Copy, Clone, Debug)]
40710 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReferenceStencilLayout.html>"]
40711 pub struct AttachmentReferenceStencilLayout {
40712     pub s_type: StructureType,
40713     pub p_next: *mut c_void,
40714     pub stencil_layout: ImageLayout,
40715 }
40716 impl ::std::default::Default for AttachmentReferenceStencilLayout {
default() -> AttachmentReferenceStencilLayout40717     fn default() -> AttachmentReferenceStencilLayout {
40718         AttachmentReferenceStencilLayout {
40719             s_type: StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
40720             p_next: ::std::ptr::null_mut(),
40721             stencil_layout: ImageLayout::default(),
40722         }
40723     }
40724 }
40725 impl AttachmentReferenceStencilLayout {
builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a>40726     pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> {
40727         AttachmentReferenceStencilLayoutBuilder {
40728             inner: AttachmentReferenceStencilLayout::default(),
40729             marker: ::std::marker::PhantomData,
40730         }
40731     }
40732 }
40733 #[repr(transparent)]
40734 pub struct AttachmentReferenceStencilLayoutBuilder<'a> {
40735     inner: AttachmentReferenceStencilLayout,
40736     marker: ::std::marker::PhantomData<&'a ()>,
40737 }
40738 unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {}
40739 unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {}
40740 impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> {
40741     type Target = AttachmentReferenceStencilLayout;
deref(&self) -> &Self::Target40742     fn deref(&self) -> &Self::Target {
40743         &self.inner
40744     }
40745 }
40746 impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40747     fn deref_mut(&mut self) -> &mut Self::Target {
40748         &mut self.inner
40749     }
40750 }
40751 impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
stencil_layout( mut self, stencil_layout: ImageLayout, ) -> AttachmentReferenceStencilLayoutBuilder<'a>40752     pub fn stencil_layout(
40753         mut self,
40754         stencil_layout: ImageLayout,
40755     ) -> AttachmentReferenceStencilLayoutBuilder<'a> {
40756         self.inner.stencil_layout = stencil_layout;
40757         self
40758     }
40759     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40760     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40761     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentReferenceStencilLayout40762     pub fn build(self) -> AttachmentReferenceStencilLayout {
40763         self.inner
40764     }
40765 }
40766 #[repr(C)]
40767 #[derive(Copy, Clone, Debug)]
40768 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionStencilLayout.html>"]
40769 pub struct AttachmentDescriptionStencilLayout {
40770     pub s_type: StructureType,
40771     pub p_next: *mut c_void,
40772     pub stencil_initial_layout: ImageLayout,
40773     pub stencil_final_layout: ImageLayout,
40774 }
40775 impl ::std::default::Default for AttachmentDescriptionStencilLayout {
default() -> AttachmentDescriptionStencilLayout40776     fn default() -> AttachmentDescriptionStencilLayout {
40777         AttachmentDescriptionStencilLayout {
40778             s_type: StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
40779             p_next: ::std::ptr::null_mut(),
40780             stencil_initial_layout: ImageLayout::default(),
40781             stencil_final_layout: ImageLayout::default(),
40782         }
40783     }
40784 }
40785 impl AttachmentDescriptionStencilLayout {
builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a>40786     pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> {
40787         AttachmentDescriptionStencilLayoutBuilder {
40788             inner: AttachmentDescriptionStencilLayout::default(),
40789             marker: ::std::marker::PhantomData,
40790         }
40791     }
40792 }
40793 #[repr(transparent)]
40794 pub struct AttachmentDescriptionStencilLayoutBuilder<'a> {
40795     inner: AttachmentDescriptionStencilLayout,
40796     marker: ::std::marker::PhantomData<&'a ()>,
40797 }
40798 unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {}
40799 unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {}
40800 impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> {
40801     type Target = AttachmentDescriptionStencilLayout;
deref(&self) -> &Self::Target40802     fn deref(&self) -> &Self::Target {
40803         &self.inner
40804     }
40805 }
40806 impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40807     fn deref_mut(&mut self) -> &mut Self::Target {
40808         &mut self.inner
40809     }
40810 }
40811 impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
stencil_initial_layout( mut self, stencil_initial_layout: ImageLayout, ) -> AttachmentDescriptionStencilLayoutBuilder<'a>40812     pub fn stencil_initial_layout(
40813         mut self,
40814         stencil_initial_layout: ImageLayout,
40815     ) -> AttachmentDescriptionStencilLayoutBuilder<'a> {
40816         self.inner.stencil_initial_layout = stencil_initial_layout;
40817         self
40818     }
stencil_final_layout( mut self, stencil_final_layout: ImageLayout, ) -> AttachmentDescriptionStencilLayoutBuilder<'a>40819     pub fn stencil_final_layout(
40820         mut self,
40821         stencil_final_layout: ImageLayout,
40822     ) -> AttachmentDescriptionStencilLayoutBuilder<'a> {
40823         self.inner.stencil_final_layout = stencil_final_layout;
40824         self
40825     }
40826     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40827     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40828     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AttachmentDescriptionStencilLayout40829     pub fn build(self) -> AttachmentDescriptionStencilLayout {
40830         self.inner
40831     }
40832 }
40833 #[repr(C)]
40834 #[derive(Copy, Clone, Debug)]
40835 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>"]
40836 pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
40837     pub s_type: StructureType,
40838     pub p_next: *mut c_void,
40839     pub pipeline_executable_info: Bool32,
40840 }
40841 impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
default() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR40842     fn default() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
40843         PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
40844             s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
40845             p_next: ::std::ptr::null_mut(),
40846             pipeline_executable_info: Bool32::default(),
40847         }
40848     }
40849 }
40850 impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a>40851     pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
40852         PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder {
40853             inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::default(),
40854             marker: ::std::marker::PhantomData,
40855         }
40856     }
40857 }
40858 #[repr(transparent)]
40859 pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
40860     inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
40861     marker: ::std::marker::PhantomData<&'a ()>,
40862 }
40863 unsafe impl ExtendsDeviceCreateInfo
40864     for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
40865 {
40866 }
40867 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {}
40868 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
40869     type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
deref(&self) -> &Self::Target40870     fn deref(&self) -> &Self::Target {
40871         &self.inner
40872     }
40873 }
40874 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40875     fn deref_mut(&mut self) -> &mut Self::Target {
40876         &mut self.inner
40877     }
40878 }
40879 impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
pipeline_executable_info( mut self, pipeline_executable_info: bool, ) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a>40880     pub fn pipeline_executable_info(
40881         mut self,
40882         pipeline_executable_info: bool,
40883     ) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
40884         self.inner.pipeline_executable_info = pipeline_executable_info.into();
40885         self
40886     }
40887     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40888     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40889     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR40890     pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
40891         self.inner
40892     }
40893 }
40894 #[repr(C)]
40895 #[derive(Copy, Clone, Debug)]
40896 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInfoKHR.html>"]
40897 pub struct PipelineInfoKHR {
40898     pub s_type: StructureType,
40899     pub p_next: *const c_void,
40900     pub pipeline: Pipeline,
40901 }
40902 impl ::std::default::Default for PipelineInfoKHR {
default() -> PipelineInfoKHR40903     fn default() -> PipelineInfoKHR {
40904         PipelineInfoKHR {
40905             s_type: StructureType::PIPELINE_INFO_KHR,
40906             p_next: ::std::ptr::null(),
40907             pipeline: Pipeline::default(),
40908         }
40909     }
40910 }
40911 impl PipelineInfoKHR {
builder<'a>() -> PipelineInfoKHRBuilder<'a>40912     pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> {
40913         PipelineInfoKHRBuilder {
40914             inner: PipelineInfoKHR::default(),
40915             marker: ::std::marker::PhantomData,
40916         }
40917     }
40918 }
40919 #[repr(transparent)]
40920 pub struct PipelineInfoKHRBuilder<'a> {
40921     inner: PipelineInfoKHR,
40922     marker: ::std::marker::PhantomData<&'a ()>,
40923 }
40924 pub unsafe trait ExtendsPipelineInfoKHR {}
40925 impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> {
40926     type Target = PipelineInfoKHR;
deref(&self) -> &Self::Target40927     fn deref(&self) -> &Self::Target {
40928         &self.inner
40929     }
40930 }
40931 impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target40932     fn deref_mut(&mut self) -> &mut Self::Target {
40933         &mut self.inner
40934     }
40935 }
40936 impl<'a> PipelineInfoKHRBuilder<'a> {
pipeline(mut self, pipeline: Pipeline) -> PipelineInfoKHRBuilder<'a>40937     pub fn pipeline(mut self, pipeline: Pipeline) -> PipelineInfoKHRBuilder<'a> {
40938         self.inner.pipeline = pipeline;
40939         self
40940     }
40941     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
40942     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
40943     #[doc = r" valid extension structs can be pushed into the chain."]
40944     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
40945     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineInfoKHR>( mut self, next: &'a mut T, ) -> PipelineInfoKHRBuilder<'a>40946     pub fn push_next<T: ExtendsPipelineInfoKHR>(
40947         mut self,
40948         next: &'a mut T,
40949     ) -> PipelineInfoKHRBuilder<'a> {
40950         unsafe {
40951             let next_ptr = next as *mut T as *mut BaseOutStructure;
40952             let last_next = ptr_chain_iter(next).last().unwrap();
40953             (*last_next).p_next = self.inner.p_next as _;
40954             self.inner.p_next = next_ptr as _;
40955         }
40956         self
40957     }
40958     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
40959     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
40960     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineInfoKHR40961     pub fn build(self) -> PipelineInfoKHR {
40962         self.inner
40963     }
40964 }
40965 #[repr(C)]
40966 #[derive(Copy, Clone)]
40967 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutablePropertiesKHR.html>"]
40968 pub struct PipelineExecutablePropertiesKHR {
40969     pub s_type: StructureType,
40970     pub p_next: *mut c_void,
40971     pub stages: ShaderStageFlags,
40972     pub name: [c_char; MAX_DESCRIPTION_SIZE],
40973     pub description: [c_char; MAX_DESCRIPTION_SIZE],
40974     pub subgroup_size: u32,
40975 }
40976 impl fmt::Debug for PipelineExecutablePropertiesKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result40977     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
40978         fmt.debug_struct("PipelineExecutablePropertiesKHR")
40979             .field("s_type", &self.s_type)
40980             .field("p_next", &self.p_next)
40981             .field("stages", &self.stages)
40982             .field("name", &unsafe {
40983                 ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
40984             })
40985             .field("description", &unsafe {
40986                 ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
40987             })
40988             .field("subgroup_size", &self.subgroup_size)
40989             .finish()
40990     }
40991 }
40992 impl ::std::default::Default for PipelineExecutablePropertiesKHR {
default() -> PipelineExecutablePropertiesKHR40993     fn default() -> PipelineExecutablePropertiesKHR {
40994         PipelineExecutablePropertiesKHR {
40995             s_type: StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR,
40996             p_next: ::std::ptr::null_mut(),
40997             stages: ShaderStageFlags::default(),
40998             name: unsafe { ::std::mem::zeroed() },
40999             description: unsafe { ::std::mem::zeroed() },
41000             subgroup_size: u32::default(),
41001         }
41002     }
41003 }
41004 impl PipelineExecutablePropertiesKHR {
builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a>41005     pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> {
41006         PipelineExecutablePropertiesKHRBuilder {
41007             inner: PipelineExecutablePropertiesKHR::default(),
41008             marker: ::std::marker::PhantomData,
41009         }
41010     }
41011 }
41012 #[repr(transparent)]
41013 pub struct PipelineExecutablePropertiesKHRBuilder<'a> {
41014     inner: PipelineExecutablePropertiesKHR,
41015     marker: ::std::marker::PhantomData<&'a ()>,
41016 }
41017 pub unsafe trait ExtendsPipelineExecutablePropertiesKHR {}
41018 impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> {
41019     type Target = PipelineExecutablePropertiesKHR;
deref(&self) -> &Self::Target41020     fn deref(&self) -> &Self::Target {
41021         &self.inner
41022     }
41023 }
41024 impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41025     fn deref_mut(&mut self) -> &mut Self::Target {
41026         &mut self.inner
41027     }
41028 }
41029 impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
stages( mut self, stages: ShaderStageFlags, ) -> PipelineExecutablePropertiesKHRBuilder<'a>41030     pub fn stages(
41031         mut self,
41032         stages: ShaderStageFlags,
41033     ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
41034         self.inner.stages = stages;
41035         self
41036     }
name( mut self, name: [c_char; MAX_DESCRIPTION_SIZE], ) -> PipelineExecutablePropertiesKHRBuilder<'a>41037     pub fn name(
41038         mut self,
41039         name: [c_char; MAX_DESCRIPTION_SIZE],
41040     ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
41041         self.inner.name = name;
41042         self
41043     }
description( mut self, description: [c_char; MAX_DESCRIPTION_SIZE], ) -> PipelineExecutablePropertiesKHRBuilder<'a>41044     pub fn description(
41045         mut self,
41046         description: [c_char; MAX_DESCRIPTION_SIZE],
41047     ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
41048         self.inner.description = description;
41049         self
41050     }
subgroup_size( mut self, subgroup_size: u32, ) -> PipelineExecutablePropertiesKHRBuilder<'a>41051     pub fn subgroup_size(
41052         mut self,
41053         subgroup_size: u32,
41054     ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
41055         self.inner.subgroup_size = subgroup_size;
41056         self
41057     }
41058     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
41059     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
41060     #[doc = r" valid extension structs can be pushed into the chain."]
41061     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
41062     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineExecutablePropertiesKHR>( mut self, next: &'a mut T, ) -> PipelineExecutablePropertiesKHRBuilder<'a>41063     pub fn push_next<T: ExtendsPipelineExecutablePropertiesKHR>(
41064         mut self,
41065         next: &'a mut T,
41066     ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
41067         unsafe {
41068             let next_ptr = next as *mut T as *mut BaseOutStructure;
41069             let last_next = ptr_chain_iter(next).last().unwrap();
41070             (*last_next).p_next = self.inner.p_next as _;
41071             self.inner.p_next = next_ptr as _;
41072         }
41073         self
41074     }
41075     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41076     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41077     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutablePropertiesKHR41078     pub fn build(self) -> PipelineExecutablePropertiesKHR {
41079         self.inner
41080     }
41081 }
41082 #[repr(C)]
41083 #[derive(Copy, Clone, Debug)]
41084 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableInfoKHR.html>"]
41085 pub struct PipelineExecutableInfoKHR {
41086     pub s_type: StructureType,
41087     pub p_next: *const c_void,
41088     pub pipeline: Pipeline,
41089     pub executable_index: u32,
41090 }
41091 impl ::std::default::Default for PipelineExecutableInfoKHR {
default() -> PipelineExecutableInfoKHR41092     fn default() -> PipelineExecutableInfoKHR {
41093         PipelineExecutableInfoKHR {
41094             s_type: StructureType::PIPELINE_EXECUTABLE_INFO_KHR,
41095             p_next: ::std::ptr::null(),
41096             pipeline: Pipeline::default(),
41097             executable_index: u32::default(),
41098         }
41099     }
41100 }
41101 impl PipelineExecutableInfoKHR {
builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a>41102     pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> {
41103         PipelineExecutableInfoKHRBuilder {
41104             inner: PipelineExecutableInfoKHR::default(),
41105             marker: ::std::marker::PhantomData,
41106         }
41107     }
41108 }
41109 #[repr(transparent)]
41110 pub struct PipelineExecutableInfoKHRBuilder<'a> {
41111     inner: PipelineExecutableInfoKHR,
41112     marker: ::std::marker::PhantomData<&'a ()>,
41113 }
41114 pub unsafe trait ExtendsPipelineExecutableInfoKHR {}
41115 impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> {
41116     type Target = PipelineExecutableInfoKHR;
deref(&self) -> &Self::Target41117     fn deref(&self) -> &Self::Target {
41118         &self.inner
41119     }
41120 }
41121 impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41122     fn deref_mut(&mut self) -> &mut Self::Target {
41123         &mut self.inner
41124     }
41125 }
41126 impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
pipeline(mut self, pipeline: Pipeline) -> PipelineExecutableInfoKHRBuilder<'a>41127     pub fn pipeline(mut self, pipeline: Pipeline) -> PipelineExecutableInfoKHRBuilder<'a> {
41128         self.inner.pipeline = pipeline;
41129         self
41130     }
executable_index( mut self, executable_index: u32, ) -> PipelineExecutableInfoKHRBuilder<'a>41131     pub fn executable_index(
41132         mut self,
41133         executable_index: u32,
41134     ) -> PipelineExecutableInfoKHRBuilder<'a> {
41135         self.inner.executable_index = executable_index;
41136         self
41137     }
41138     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
41139     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
41140     #[doc = r" valid extension structs can be pushed into the chain."]
41141     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
41142     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineExecutableInfoKHR>( mut self, next: &'a mut T, ) -> PipelineExecutableInfoKHRBuilder<'a>41143     pub fn push_next<T: ExtendsPipelineExecutableInfoKHR>(
41144         mut self,
41145         next: &'a mut T,
41146     ) -> PipelineExecutableInfoKHRBuilder<'a> {
41147         unsafe {
41148             let next_ptr = next as *mut T as *mut BaseOutStructure;
41149             let last_next = ptr_chain_iter(next).last().unwrap();
41150             (*last_next).p_next = self.inner.p_next as _;
41151             self.inner.p_next = next_ptr as _;
41152         }
41153         self
41154     }
41155     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41156     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41157     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutableInfoKHR41158     pub fn build(self) -> PipelineExecutableInfoKHR {
41159         self.inner
41160     }
41161 }
41162 #[repr(C)]
41163 #[derive(Copy, Clone)]
41164 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html>"]
41165 pub union PipelineExecutableStatisticValueKHR {
41166     pub b32: Bool32,
41167     pub i64: i64,
41168     pub u64: u64,
41169     pub f64: f64,
41170 }
41171 impl ::std::default::Default for PipelineExecutableStatisticValueKHR {
default() -> PipelineExecutableStatisticValueKHR41172     fn default() -> PipelineExecutableStatisticValueKHR {
41173         unsafe { ::std::mem::zeroed() }
41174     }
41175 }
41176 #[repr(C)]
41177 #[derive(Copy, Clone)]
41178 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableStatisticKHR.html>"]
41179 pub struct PipelineExecutableStatisticKHR {
41180     pub s_type: StructureType,
41181     pub p_next: *mut c_void,
41182     pub name: [c_char; MAX_DESCRIPTION_SIZE],
41183     pub description: [c_char; MAX_DESCRIPTION_SIZE],
41184     pub format: PipelineExecutableStatisticFormatKHR,
41185     pub value: PipelineExecutableStatisticValueKHR,
41186 }
41187 impl fmt::Debug for PipelineExecutableStatisticKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result41188     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
41189         fmt.debug_struct("PipelineExecutableStatisticKHR")
41190             .field("s_type", &self.s_type)
41191             .field("p_next", &self.p_next)
41192             .field("name", &unsafe {
41193                 ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
41194             })
41195             .field("description", &unsafe {
41196                 ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
41197             })
41198             .field("format", &self.format)
41199             .field("value", &"union")
41200             .finish()
41201     }
41202 }
41203 impl ::std::default::Default for PipelineExecutableStatisticKHR {
default() -> PipelineExecutableStatisticKHR41204     fn default() -> PipelineExecutableStatisticKHR {
41205         PipelineExecutableStatisticKHR {
41206             s_type: StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR,
41207             p_next: ::std::ptr::null_mut(),
41208             name: unsafe { ::std::mem::zeroed() },
41209             description: unsafe { ::std::mem::zeroed() },
41210             format: PipelineExecutableStatisticFormatKHR::default(),
41211             value: PipelineExecutableStatisticValueKHR::default(),
41212         }
41213     }
41214 }
41215 impl PipelineExecutableStatisticKHR {
builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a>41216     pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> {
41217         PipelineExecutableStatisticKHRBuilder {
41218             inner: PipelineExecutableStatisticKHR::default(),
41219             marker: ::std::marker::PhantomData,
41220         }
41221     }
41222 }
41223 #[repr(transparent)]
41224 pub struct PipelineExecutableStatisticKHRBuilder<'a> {
41225     inner: PipelineExecutableStatisticKHR,
41226     marker: ::std::marker::PhantomData<&'a ()>,
41227 }
41228 pub unsafe trait ExtendsPipelineExecutableStatisticKHR {}
41229 impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> {
41230     type Target = PipelineExecutableStatisticKHR;
deref(&self) -> &Self::Target41231     fn deref(&self) -> &Self::Target {
41232         &self.inner
41233     }
41234 }
41235 impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41236     fn deref_mut(&mut self) -> &mut Self::Target {
41237         &mut self.inner
41238     }
41239 }
41240 impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
name( mut self, name: [c_char; MAX_DESCRIPTION_SIZE], ) -> PipelineExecutableStatisticKHRBuilder<'a>41241     pub fn name(
41242         mut self,
41243         name: [c_char; MAX_DESCRIPTION_SIZE],
41244     ) -> PipelineExecutableStatisticKHRBuilder<'a> {
41245         self.inner.name = name;
41246         self
41247     }
description( mut self, description: [c_char; MAX_DESCRIPTION_SIZE], ) -> PipelineExecutableStatisticKHRBuilder<'a>41248     pub fn description(
41249         mut self,
41250         description: [c_char; MAX_DESCRIPTION_SIZE],
41251     ) -> PipelineExecutableStatisticKHRBuilder<'a> {
41252         self.inner.description = description;
41253         self
41254     }
format( mut self, format: PipelineExecutableStatisticFormatKHR, ) -> PipelineExecutableStatisticKHRBuilder<'a>41255     pub fn format(
41256         mut self,
41257         format: PipelineExecutableStatisticFormatKHR,
41258     ) -> PipelineExecutableStatisticKHRBuilder<'a> {
41259         self.inner.format = format;
41260         self
41261     }
value( mut self, value: PipelineExecutableStatisticValueKHR, ) -> PipelineExecutableStatisticKHRBuilder<'a>41262     pub fn value(
41263         mut self,
41264         value: PipelineExecutableStatisticValueKHR,
41265     ) -> PipelineExecutableStatisticKHRBuilder<'a> {
41266         self.inner.value = value;
41267         self
41268     }
41269     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
41270     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
41271     #[doc = r" valid extension structs can be pushed into the chain."]
41272     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
41273     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineExecutableStatisticKHR>( mut self, next: &'a mut T, ) -> PipelineExecutableStatisticKHRBuilder<'a>41274     pub fn push_next<T: ExtendsPipelineExecutableStatisticKHR>(
41275         mut self,
41276         next: &'a mut T,
41277     ) -> PipelineExecutableStatisticKHRBuilder<'a> {
41278         unsafe {
41279             let next_ptr = next as *mut T as *mut BaseOutStructure;
41280             let last_next = ptr_chain_iter(next).last().unwrap();
41281             (*last_next).p_next = self.inner.p_next as _;
41282             self.inner.p_next = next_ptr as _;
41283         }
41284         self
41285     }
41286     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41287     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41288     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutableStatisticKHR41289     pub fn build(self) -> PipelineExecutableStatisticKHR {
41290         self.inner
41291     }
41292 }
41293 #[repr(C)]
41294 #[derive(Copy, Clone)]
41295 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html>"]
41296 pub struct PipelineExecutableInternalRepresentationKHR {
41297     pub s_type: StructureType,
41298     pub p_next: *mut c_void,
41299     pub name: [c_char; MAX_DESCRIPTION_SIZE],
41300     pub description: [c_char; MAX_DESCRIPTION_SIZE],
41301     pub is_text: Bool32,
41302     pub data_size: usize,
41303     pub p_data: *mut c_void,
41304 }
41305 impl fmt::Debug for PipelineExecutableInternalRepresentationKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result41306     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
41307         fmt.debug_struct("PipelineExecutableInternalRepresentationKHR")
41308             .field("s_type", &self.s_type)
41309             .field("p_next", &self.p_next)
41310             .field("name", &unsafe {
41311                 ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
41312             })
41313             .field("description", &unsafe {
41314                 ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
41315             })
41316             .field("is_text", &self.is_text)
41317             .field("data_size", &self.data_size)
41318             .field("p_data", &self.p_data)
41319             .finish()
41320     }
41321 }
41322 impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR {
default() -> PipelineExecutableInternalRepresentationKHR41323     fn default() -> PipelineExecutableInternalRepresentationKHR {
41324         PipelineExecutableInternalRepresentationKHR {
41325             s_type: StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
41326             p_next: ::std::ptr::null_mut(),
41327             name: unsafe { ::std::mem::zeroed() },
41328             description: unsafe { ::std::mem::zeroed() },
41329             is_text: Bool32::default(),
41330             data_size: usize::default(),
41331             p_data: ::std::ptr::null_mut(),
41332         }
41333     }
41334 }
41335 impl PipelineExecutableInternalRepresentationKHR {
builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a>41336     pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41337         PipelineExecutableInternalRepresentationKHRBuilder {
41338             inner: PipelineExecutableInternalRepresentationKHR::default(),
41339             marker: ::std::marker::PhantomData,
41340         }
41341     }
41342 }
41343 #[repr(transparent)]
41344 pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41345     inner: PipelineExecutableInternalRepresentationKHR,
41346     marker: ::std::marker::PhantomData<&'a ()>,
41347 }
41348 pub unsafe trait ExtendsPipelineExecutableInternalRepresentationKHR {}
41349 impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41350     type Target = PipelineExecutableInternalRepresentationKHR;
deref(&self) -> &Self::Target41351     fn deref(&self) -> &Self::Target {
41352         &self.inner
41353     }
41354 }
41355 impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41356     fn deref_mut(&mut self) -> &mut Self::Target {
41357         &mut self.inner
41358     }
41359 }
41360 impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
name( mut self, name: [c_char; MAX_DESCRIPTION_SIZE], ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a>41361     pub fn name(
41362         mut self,
41363         name: [c_char; MAX_DESCRIPTION_SIZE],
41364     ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41365         self.inner.name = name;
41366         self
41367     }
description( mut self, description: [c_char; MAX_DESCRIPTION_SIZE], ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a>41368     pub fn description(
41369         mut self,
41370         description: [c_char; MAX_DESCRIPTION_SIZE],
41371     ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41372         self.inner.description = description;
41373         self
41374     }
is_text( mut self, is_text: bool, ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a>41375     pub fn is_text(
41376         mut self,
41377         is_text: bool,
41378     ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41379         self.inner.is_text = is_text.into();
41380         self
41381     }
data( mut self, data: &'a mut [u8], ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a>41382     pub fn data(
41383         mut self,
41384         data: &'a mut [u8],
41385     ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41386         self.inner.data_size = data.len() as _;
41387         self.inner.p_data = data.as_mut_ptr() as *mut c_void;
41388         self
41389     }
41390     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
41391     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
41392     #[doc = r" valid extension structs can be pushed into the chain."]
41393     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
41394     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineExecutableInternalRepresentationKHR>( mut self, next: &'a mut T, ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a>41395     pub fn push_next<T: ExtendsPipelineExecutableInternalRepresentationKHR>(
41396         mut self,
41397         next: &'a mut T,
41398     ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
41399         unsafe {
41400             let next_ptr = next as *mut T as *mut BaseOutStructure;
41401             let last_next = ptr_chain_iter(next).last().unwrap();
41402             (*last_next).p_next = self.inner.p_next as _;
41403             self.inner.p_next = next_ptr as _;
41404         }
41405         self
41406     }
41407     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41408     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41409     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineExecutableInternalRepresentationKHR41410     pub fn build(self) -> PipelineExecutableInternalRepresentationKHR {
41411         self.inner
41412     }
41413 }
41414 #[repr(C)]
41415 #[derive(Copy, Clone, Debug)]
41416 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.html>"]
41417 pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
41418     pub s_type: StructureType,
41419     pub p_next: *mut c_void,
41420     pub shader_demote_to_helper_invocation: Bool32,
41421 }
41422 impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
default() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT41423     fn default() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
41424         PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
41425             s_type: StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT,
41426             p_next: ::std::ptr::null_mut(),
41427             shader_demote_to_helper_invocation: Bool32::default(),
41428         }
41429     }
41430 }
41431 impl PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a>41432     pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
41433         PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder {
41434             inner: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::default(),
41435             marker: ::std::marker::PhantomData,
41436         }
41437     }
41438 }
41439 #[repr(transparent)]
41440 pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
41441     inner: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT,
41442     marker: ::std::marker::PhantomData<&'a ()>,
41443 }
41444 unsafe impl ExtendsDeviceCreateInfo
41445     for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'_>
41446 {
41447 }
41448 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {}
41449 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
41450     type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
deref(&self) -> &Self::Target41451     fn deref(&self) -> &Self::Target {
41452         &self.inner
41453     }
41454 }
41455 impl<'a> ::std::ops::DerefMut
41456     for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a>
41457 {
deref_mut(&mut self) -> &mut Self::Target41458     fn deref_mut(&mut self) -> &mut Self::Target {
41459         &mut self.inner
41460     }
41461 }
41462 impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
shader_demote_to_helper_invocation( mut self, shader_demote_to_helper_invocation: bool, ) -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a>41463     pub fn shader_demote_to_helper_invocation(
41464         mut self,
41465         shader_demote_to_helper_invocation: bool,
41466     ) -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
41467         self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
41468         self
41469     }
41470     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41471     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41472     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT41473     pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
41474         self.inner
41475     }
41476 }
41477 #[repr(C)]
41478 #[derive(Copy, Clone, Debug)]
41479 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>"]
41480 pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
41481     pub s_type: StructureType,
41482     pub p_next: *mut c_void,
41483     pub texel_buffer_alignment: Bool32,
41484 }
41485 impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
default() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT41486     fn default() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
41487         PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
41488             s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
41489             p_next: ::std::ptr::null_mut(),
41490             texel_buffer_alignment: Bool32::default(),
41491         }
41492     }
41493 }
41494 impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a>41495     pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
41496         PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder {
41497             inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT::default(),
41498             marker: ::std::marker::PhantomData,
41499         }
41500     }
41501 }
41502 #[repr(transparent)]
41503 pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
41504     inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
41505     marker: ::std::marker::PhantomData<&'a ()>,
41506 }
41507 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {}
41508 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
41509 impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
41510     type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
deref(&self) -> &Self::Target41511     fn deref(&self) -> &Self::Target {
41512         &self.inner
41513     }
41514 }
41515 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41516     fn deref_mut(&mut self) -> &mut Self::Target {
41517         &mut self.inner
41518     }
41519 }
41520 impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
texel_buffer_alignment( mut self, texel_buffer_alignment: bool, ) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a>41521     pub fn texel_buffer_alignment(
41522         mut self,
41523         texel_buffer_alignment: bool,
41524     ) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
41525         self.inner.texel_buffer_alignment = texel_buffer_alignment.into();
41526         self
41527     }
41528     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41529     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41530     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT41531     pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
41532         self.inner
41533     }
41534 }
41535 #[repr(C)]
41536 #[derive(Copy, Clone, Debug)]
41537 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html>"]
41538 pub struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
41539     pub s_type: StructureType,
41540     pub p_next: *mut c_void,
41541     pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
41542     pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
41543     pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
41544     pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
41545 }
41546 impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
default() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT41547     fn default() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
41548         PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
41549             s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
41550             p_next: ::std::ptr::null_mut(),
41551             storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
41552             storage_texel_buffer_offset_single_texel_alignment: Bool32::default(),
41553             uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
41554             uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(),
41555         }
41556     }
41557 }
41558 impl PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a>41559     pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
41560         PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder {
41561             inner: PhysicalDeviceTexelBufferAlignmentPropertiesEXT::default(),
41562             marker: ::std::marker::PhantomData,
41563         }
41564     }
41565 }
41566 #[repr(transparent)]
41567 pub struct PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
41568     inner: PhysicalDeviceTexelBufferAlignmentPropertiesEXT,
41569     marker: ::std::marker::PhantomData<&'a ()>,
41570 }
41571 unsafe impl ExtendsPhysicalDeviceProperties2
41572     for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'_>
41573 {
41574 }
41575 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentPropertiesEXT {}
41576 impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
41577     type Target = PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
deref(&self) -> &Self::Target41578     fn deref(&self) -> &Self::Target {
41579         &self.inner
41580     }
41581 }
41582 impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41583     fn deref_mut(&mut self) -> &mut Self::Target {
41584         &mut self.inner
41585     }
41586 }
41587 impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
storage_texel_buffer_offset_alignment_bytes( mut self, storage_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a>41588     pub fn storage_texel_buffer_offset_alignment_bytes(
41589         mut self,
41590         storage_texel_buffer_offset_alignment_bytes: DeviceSize,
41591     ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
41592         self.inner.storage_texel_buffer_offset_alignment_bytes =
41593             storage_texel_buffer_offset_alignment_bytes;
41594         self
41595     }
storage_texel_buffer_offset_single_texel_alignment( mut self, storage_texel_buffer_offset_single_texel_alignment: bool, ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a>41596     pub fn storage_texel_buffer_offset_single_texel_alignment(
41597         mut self,
41598         storage_texel_buffer_offset_single_texel_alignment: bool,
41599     ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
41600         self.inner
41601             .storage_texel_buffer_offset_single_texel_alignment =
41602             storage_texel_buffer_offset_single_texel_alignment.into();
41603         self
41604     }
uniform_texel_buffer_offset_alignment_bytes( mut self, uniform_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a>41605     pub fn uniform_texel_buffer_offset_alignment_bytes(
41606         mut self,
41607         uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
41608     ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
41609         self.inner.uniform_texel_buffer_offset_alignment_bytes =
41610             uniform_texel_buffer_offset_alignment_bytes;
41611         self
41612     }
uniform_texel_buffer_offset_single_texel_alignment( mut self, uniform_texel_buffer_offset_single_texel_alignment: bool, ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a>41613     pub fn uniform_texel_buffer_offset_single_texel_alignment(
41614         mut self,
41615         uniform_texel_buffer_offset_single_texel_alignment: bool,
41616     ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
41617         self.inner
41618             .uniform_texel_buffer_offset_single_texel_alignment =
41619             uniform_texel_buffer_offset_single_texel_alignment.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."]
build(self) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT41625     pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
41626         self.inner
41627     }
41628 }
41629 #[repr(C)]
41630 #[derive(Copy, Clone, Debug)]
41631 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.html>"]
41632 pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXT {
41633     pub s_type: StructureType,
41634     pub p_next: *mut c_void,
41635     pub subgroup_size_control: Bool32,
41636     pub compute_full_subgroups: Bool32,
41637 }
41638 impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeaturesEXT {
default() -> PhysicalDeviceSubgroupSizeControlFeaturesEXT41639     fn default() -> PhysicalDeviceSubgroupSizeControlFeaturesEXT {
41640         PhysicalDeviceSubgroupSizeControlFeaturesEXT {
41641             s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT,
41642             p_next: ::std::ptr::null_mut(),
41643             subgroup_size_control: Bool32::default(),
41644             compute_full_subgroups: Bool32::default(),
41645         }
41646     }
41647 }
41648 impl PhysicalDeviceSubgroupSizeControlFeaturesEXT {
builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a>41649     pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
41650         PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder {
41651             inner: PhysicalDeviceSubgroupSizeControlFeaturesEXT::default(),
41652             marker: ::std::marker::PhantomData,
41653         }
41654     }
41655 }
41656 #[repr(transparent)]
41657 pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
41658     inner: PhysicalDeviceSubgroupSizeControlFeaturesEXT,
41659     marker: ::std::marker::PhantomData<&'a ()>,
41660 }
41661 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'_> {}
41662 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXT {}
41663 impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
41664     type Target = PhysicalDeviceSubgroupSizeControlFeaturesEXT;
deref(&self) -> &Self::Target41665     fn deref(&self) -> &Self::Target {
41666         &self.inner
41667     }
41668 }
41669 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41670     fn deref_mut(&mut self) -> &mut Self::Target {
41671         &mut self.inner
41672     }
41673 }
41674 impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
subgroup_size_control( mut self, subgroup_size_control: bool, ) -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a>41675     pub fn subgroup_size_control(
41676         mut self,
41677         subgroup_size_control: bool,
41678     ) -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
41679         self.inner.subgroup_size_control = subgroup_size_control.into();
41680         self
41681     }
compute_full_subgroups( mut self, compute_full_subgroups: bool, ) -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a>41682     pub fn compute_full_subgroups(
41683         mut self,
41684         compute_full_subgroups: bool,
41685     ) -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
41686         self.inner.compute_full_subgroups = compute_full_subgroups.into();
41687         self
41688     }
41689     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41690     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41691     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubgroupSizeControlFeaturesEXT41692     pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeaturesEXT {
41693         self.inner
41694     }
41695 }
41696 #[repr(C)]
41697 #[derive(Copy, Clone, Debug)]
41698 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html>"]
41699 pub struct PhysicalDeviceSubgroupSizeControlPropertiesEXT {
41700     pub s_type: StructureType,
41701     pub p_next: *mut c_void,
41702     pub min_subgroup_size: u32,
41703     pub max_subgroup_size: u32,
41704     pub max_compute_workgroup_subgroups: u32,
41705     pub required_subgroup_size_stages: ShaderStageFlags,
41706 }
41707 impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlPropertiesEXT {
default() -> PhysicalDeviceSubgroupSizeControlPropertiesEXT41708     fn default() -> PhysicalDeviceSubgroupSizeControlPropertiesEXT {
41709         PhysicalDeviceSubgroupSizeControlPropertiesEXT {
41710             s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT,
41711             p_next: ::std::ptr::null_mut(),
41712             min_subgroup_size: u32::default(),
41713             max_subgroup_size: u32::default(),
41714             max_compute_workgroup_subgroups: u32::default(),
41715             required_subgroup_size_stages: ShaderStageFlags::default(),
41716         }
41717     }
41718 }
41719 impl PhysicalDeviceSubgroupSizeControlPropertiesEXT {
builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a>41720     pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
41721         PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder {
41722             inner: PhysicalDeviceSubgroupSizeControlPropertiesEXT::default(),
41723             marker: ::std::marker::PhantomData,
41724         }
41725     }
41726 }
41727 #[repr(transparent)]
41728 pub struct PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
41729     inner: PhysicalDeviceSubgroupSizeControlPropertiesEXT,
41730     marker: ::std::marker::PhantomData<&'a ()>,
41731 }
41732 unsafe impl ExtendsPhysicalDeviceProperties2
41733     for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'_>
41734 {
41735 }
41736 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlPropertiesEXT {}
41737 impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
41738     type Target = PhysicalDeviceSubgroupSizeControlPropertiesEXT;
deref(&self) -> &Self::Target41739     fn deref(&self) -> &Self::Target {
41740         &self.inner
41741     }
41742 }
41743 impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41744     fn deref_mut(&mut self) -> &mut Self::Target {
41745         &mut self.inner
41746     }
41747 }
41748 impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
min_subgroup_size( mut self, min_subgroup_size: u32, ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a>41749     pub fn min_subgroup_size(
41750         mut self,
41751         min_subgroup_size: u32,
41752     ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
41753         self.inner.min_subgroup_size = min_subgroup_size;
41754         self
41755     }
max_subgroup_size( mut self, max_subgroup_size: u32, ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a>41756     pub fn max_subgroup_size(
41757         mut self,
41758         max_subgroup_size: u32,
41759     ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
41760         self.inner.max_subgroup_size = max_subgroup_size;
41761         self
41762     }
max_compute_workgroup_subgroups( mut self, max_compute_workgroup_subgroups: u32, ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a>41763     pub fn max_compute_workgroup_subgroups(
41764         mut self,
41765         max_compute_workgroup_subgroups: u32,
41766     ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
41767         self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
41768         self
41769     }
required_subgroup_size_stages( mut self, required_subgroup_size_stages: ShaderStageFlags, ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a>41770     pub fn required_subgroup_size_stages(
41771         mut self,
41772         required_subgroup_size_stages: ShaderStageFlags,
41773     ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
41774         self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
41775         self
41776     }
41777     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41778     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41779     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceSubgroupSizeControlPropertiesEXT41780     pub fn build(self) -> PhysicalDeviceSubgroupSizeControlPropertiesEXT {
41781         self.inner
41782     }
41783 }
41784 #[repr(C)]
41785 #[derive(Copy, Clone, Debug)]
41786 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.html>"]
41787 pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
41788     pub s_type: StructureType,
41789     pub p_next: *mut c_void,
41790     pub required_subgroup_size: u32,
41791 }
41792 impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
default() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT41793     fn default() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
41794         PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
41795             s_type: StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
41796             p_next: ::std::ptr::null_mut(),
41797             required_subgroup_size: u32::default(),
41798         }
41799     }
41800 }
41801 impl PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a>41802     pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
41803         PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder {
41804             inner: PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::default(),
41805             marker: ::std::marker::PhantomData,
41806         }
41807     }
41808 }
41809 #[repr(transparent)]
41810 pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
41811     inner: PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT,
41812     marker: ::std::marker::PhantomData<&'a ()>,
41813 }
41814 unsafe impl ExtendsPipelineShaderStageCreateInfo
41815     for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'_>
41816 {
41817 }
41818 unsafe impl ExtendsPipelineShaderStageCreateInfo
41819     for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
41820 {
41821 }
41822 impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
41823     type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
deref(&self) -> &Self::Target41824     fn deref(&self) -> &Self::Target {
41825         &self.inner
41826     }
41827 }
41828 impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41829     fn deref_mut(&mut self) -> &mut Self::Target {
41830         &mut self.inner
41831     }
41832 }
41833 impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
required_subgroup_size( mut self, required_subgroup_size: u32, ) -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a>41834     pub fn required_subgroup_size(
41835         mut self,
41836         required_subgroup_size: u32,
41837     ) -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
41838         self.inner.required_subgroup_size = required_subgroup_size;
41839         self
41840     }
41841     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41842     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41843     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT41844     pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
41845         self.inner
41846     }
41847 }
41848 #[repr(C)]
41849 #[derive(Copy, Clone, Debug)]
41850 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>"]
41851 pub struct MemoryOpaqueCaptureAddressAllocateInfo {
41852     pub s_type: StructureType,
41853     pub p_next: *const c_void,
41854     pub opaque_capture_address: u64,
41855 }
41856 impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo {
default() -> MemoryOpaqueCaptureAddressAllocateInfo41857     fn default() -> MemoryOpaqueCaptureAddressAllocateInfo {
41858         MemoryOpaqueCaptureAddressAllocateInfo {
41859             s_type: StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
41860             p_next: ::std::ptr::null(),
41861             opaque_capture_address: u64::default(),
41862         }
41863     }
41864 }
41865 impl MemoryOpaqueCaptureAddressAllocateInfo {
builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a>41866     pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
41867         MemoryOpaqueCaptureAddressAllocateInfoBuilder {
41868             inner: MemoryOpaqueCaptureAddressAllocateInfo::default(),
41869             marker: ::std::marker::PhantomData,
41870         }
41871     }
41872 }
41873 #[repr(transparent)]
41874 pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
41875     inner: MemoryOpaqueCaptureAddressAllocateInfo,
41876     marker: ::std::marker::PhantomData<&'a ()>,
41877 }
41878 unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {}
41879 unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {}
41880 impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
41881     type Target = MemoryOpaqueCaptureAddressAllocateInfo;
deref(&self) -> &Self::Target41882     fn deref(&self) -> &Self::Target {
41883         &self.inner
41884     }
41885 }
41886 impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41887     fn deref_mut(&mut self) -> &mut Self::Target {
41888         &mut self.inner
41889     }
41890 }
41891 impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
opaque_capture_address( mut self, opaque_capture_address: u64, ) -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a>41892     pub fn opaque_capture_address(
41893         mut self,
41894         opaque_capture_address: u64,
41895     ) -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
41896         self.inner.opaque_capture_address = opaque_capture_address;
41897         self
41898     }
41899     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41900     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41901     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MemoryOpaqueCaptureAddressAllocateInfo41902     pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo {
41903         self.inner
41904     }
41905 }
41906 #[repr(C)]
41907 #[derive(Copy, Clone, Debug)]
41908 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>"]
41909 pub struct DeviceMemoryOpaqueCaptureAddressInfo {
41910     pub s_type: StructureType,
41911     pub p_next: *const c_void,
41912     pub memory: DeviceMemory,
41913 }
41914 impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo {
default() -> DeviceMemoryOpaqueCaptureAddressInfo41915     fn default() -> DeviceMemoryOpaqueCaptureAddressInfo {
41916         DeviceMemoryOpaqueCaptureAddressInfo {
41917             s_type: StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
41918             p_next: ::std::ptr::null(),
41919             memory: DeviceMemory::default(),
41920         }
41921     }
41922 }
41923 impl DeviceMemoryOpaqueCaptureAddressInfo {
builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a>41924     pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
41925         DeviceMemoryOpaqueCaptureAddressInfoBuilder {
41926             inner: DeviceMemoryOpaqueCaptureAddressInfo::default(),
41927             marker: ::std::marker::PhantomData,
41928         }
41929     }
41930 }
41931 #[repr(transparent)]
41932 pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
41933     inner: DeviceMemoryOpaqueCaptureAddressInfo,
41934     marker: ::std::marker::PhantomData<&'a ()>,
41935 }
41936 pub unsafe trait ExtendsDeviceMemoryOpaqueCaptureAddressInfo {}
41937 impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
41938     type Target = DeviceMemoryOpaqueCaptureAddressInfo;
deref(&self) -> &Self::Target41939     fn deref(&self) -> &Self::Target {
41940         &self.inner
41941     }
41942 }
41943 impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target41944     fn deref_mut(&mut self) -> &mut Self::Target {
41945         &mut self.inner
41946     }
41947 }
41948 impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
memory( mut self, memory: DeviceMemory, ) -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a>41949     pub fn memory(
41950         mut self,
41951         memory: DeviceMemory,
41952     ) -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
41953         self.inner.memory = memory;
41954         self
41955     }
41956     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
41957     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
41958     #[doc = r" valid extension structs can be pushed into the chain."]
41959     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
41960     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsDeviceMemoryOpaqueCaptureAddressInfo>( mut self, next: &'a mut T, ) -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a>41961     pub fn push_next<T: ExtendsDeviceMemoryOpaqueCaptureAddressInfo>(
41962         mut self,
41963         next: &'a mut T,
41964     ) -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
41965         unsafe {
41966             let next_ptr = next as *mut T as *mut BaseOutStructure;
41967             let last_next = ptr_chain_iter(next).last().unwrap();
41968             (*last_next).p_next = self.inner.p_next as _;
41969             self.inner.p_next = next_ptr as _;
41970         }
41971         self
41972     }
41973     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
41974     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
41975     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceMemoryOpaqueCaptureAddressInfo41976     pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo {
41977         self.inner
41978     }
41979 }
41980 #[repr(C)]
41981 #[derive(Copy, Clone, Debug)]
41982 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>"]
41983 pub struct PhysicalDeviceLineRasterizationFeaturesEXT {
41984     pub s_type: StructureType,
41985     pub p_next: *mut c_void,
41986     pub rectangular_lines: Bool32,
41987     pub bresenham_lines: Bool32,
41988     pub smooth_lines: Bool32,
41989     pub stippled_rectangular_lines: Bool32,
41990     pub stippled_bresenham_lines: Bool32,
41991     pub stippled_smooth_lines: Bool32,
41992 }
41993 impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT {
default() -> PhysicalDeviceLineRasterizationFeaturesEXT41994     fn default() -> PhysicalDeviceLineRasterizationFeaturesEXT {
41995         PhysicalDeviceLineRasterizationFeaturesEXT {
41996             s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
41997             p_next: ::std::ptr::null_mut(),
41998             rectangular_lines: Bool32::default(),
41999             bresenham_lines: Bool32::default(),
42000             smooth_lines: Bool32::default(),
42001             stippled_rectangular_lines: Bool32::default(),
42002             stippled_bresenham_lines: Bool32::default(),
42003             stippled_smooth_lines: Bool32::default(),
42004         }
42005     }
42006 }
42007 impl PhysicalDeviceLineRasterizationFeaturesEXT {
builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>42008     pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42009         PhysicalDeviceLineRasterizationFeaturesEXTBuilder {
42010             inner: PhysicalDeviceLineRasterizationFeaturesEXT::default(),
42011             marker: ::std::marker::PhantomData,
42012         }
42013     }
42014 }
42015 #[repr(transparent)]
42016 pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42017     inner: PhysicalDeviceLineRasterizationFeaturesEXT,
42018     marker: ::std::marker::PhantomData<&'a ()>,
42019 }
42020 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {}
42021 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {}
42022 impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42023     type Target = PhysicalDeviceLineRasterizationFeaturesEXT;
deref(&self) -> &Self::Target42024     fn deref(&self) -> &Self::Target {
42025         &self.inner
42026     }
42027 }
42028 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42029     fn deref_mut(&mut self) -> &mut Self::Target {
42030         &mut self.inner
42031     }
42032 }
42033 impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
rectangular_lines( mut self, rectangular_lines: bool, ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>42034     pub fn rectangular_lines(
42035         mut self,
42036         rectangular_lines: bool,
42037     ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42038         self.inner.rectangular_lines = rectangular_lines.into();
42039         self
42040     }
bresenham_lines( mut self, bresenham_lines: bool, ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>42041     pub fn bresenham_lines(
42042         mut self,
42043         bresenham_lines: bool,
42044     ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42045         self.inner.bresenham_lines = bresenham_lines.into();
42046         self
42047     }
smooth_lines( mut self, smooth_lines: bool, ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>42048     pub fn smooth_lines(
42049         mut self,
42050         smooth_lines: bool,
42051     ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42052         self.inner.smooth_lines = smooth_lines.into();
42053         self
42054     }
stippled_rectangular_lines( mut self, stippled_rectangular_lines: bool, ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>42055     pub fn stippled_rectangular_lines(
42056         mut self,
42057         stippled_rectangular_lines: bool,
42058     ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42059         self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into();
42060         self
42061     }
stippled_bresenham_lines( mut self, stippled_bresenham_lines: bool, ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>42062     pub fn stippled_bresenham_lines(
42063         mut self,
42064         stippled_bresenham_lines: bool,
42065     ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42066         self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into();
42067         self
42068     }
stippled_smooth_lines( mut self, stippled_smooth_lines: bool, ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>42069     pub fn stippled_smooth_lines(
42070         mut self,
42071         stippled_smooth_lines: bool,
42072     ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
42073         self.inner.stippled_smooth_lines = stippled_smooth_lines.into();
42074         self
42075     }
42076     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42077     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42078     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT42079     pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT {
42080         self.inner
42081     }
42082 }
42083 #[repr(C)]
42084 #[derive(Copy, Clone, Debug)]
42085 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>"]
42086 pub struct PhysicalDeviceLineRasterizationPropertiesEXT {
42087     pub s_type: StructureType,
42088     pub p_next: *mut c_void,
42089     pub line_sub_pixel_precision_bits: u32,
42090 }
42091 impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT {
default() -> PhysicalDeviceLineRasterizationPropertiesEXT42092     fn default() -> PhysicalDeviceLineRasterizationPropertiesEXT {
42093         PhysicalDeviceLineRasterizationPropertiesEXT {
42094             s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
42095             p_next: ::std::ptr::null_mut(),
42096             line_sub_pixel_precision_bits: u32::default(),
42097         }
42098     }
42099 }
42100 impl PhysicalDeviceLineRasterizationPropertiesEXT {
builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a>42101     pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
42102         PhysicalDeviceLineRasterizationPropertiesEXTBuilder {
42103             inner: PhysicalDeviceLineRasterizationPropertiesEXT::default(),
42104             marker: ::std::marker::PhantomData,
42105         }
42106     }
42107 }
42108 #[repr(transparent)]
42109 pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
42110     inner: PhysicalDeviceLineRasterizationPropertiesEXT,
42111     marker: ::std::marker::PhantomData<&'a ()>,
42112 }
42113 unsafe impl ExtendsPhysicalDeviceProperties2
42114     for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_>
42115 {
42116 }
42117 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {}
42118 impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
42119     type Target = PhysicalDeviceLineRasterizationPropertiesEXT;
deref(&self) -> &Self::Target42120     fn deref(&self) -> &Self::Target {
42121         &self.inner
42122     }
42123 }
42124 impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42125     fn deref_mut(&mut self) -> &mut Self::Target {
42126         &mut self.inner
42127     }
42128 }
42129 impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
line_sub_pixel_precision_bits( mut self, line_sub_pixel_precision_bits: u32, ) -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a>42130     pub fn line_sub_pixel_precision_bits(
42131         mut self,
42132         line_sub_pixel_precision_bits: u32,
42133     ) -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
42134         self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits;
42135         self
42136     }
42137     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42138     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42139     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT42140     pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT {
42141         self.inner
42142     }
42143 }
42144 #[repr(C)]
42145 #[derive(Copy, Clone, Debug)]
42146 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>"]
42147 pub struct PipelineRasterizationLineStateCreateInfoEXT {
42148     pub s_type: StructureType,
42149     pub p_next: *const c_void,
42150     pub line_rasterization_mode: LineRasterizationModeEXT,
42151     pub stippled_line_enable: Bool32,
42152     pub line_stipple_factor: u32,
42153     pub line_stipple_pattern: u16,
42154 }
42155 impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT {
default() -> PipelineRasterizationLineStateCreateInfoEXT42156     fn default() -> PipelineRasterizationLineStateCreateInfoEXT {
42157         PipelineRasterizationLineStateCreateInfoEXT {
42158             s_type: StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
42159             p_next: ::std::ptr::null(),
42160             line_rasterization_mode: LineRasterizationModeEXT::default(),
42161             stippled_line_enable: Bool32::default(),
42162             line_stipple_factor: u32::default(),
42163             line_stipple_pattern: u16::default(),
42164         }
42165     }
42166 }
42167 impl PipelineRasterizationLineStateCreateInfoEXT {
builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a>42168     pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
42169         PipelineRasterizationLineStateCreateInfoEXTBuilder {
42170             inner: PipelineRasterizationLineStateCreateInfoEXT::default(),
42171             marker: ::std::marker::PhantomData,
42172         }
42173     }
42174 }
42175 #[repr(transparent)]
42176 pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
42177     inner: PipelineRasterizationLineStateCreateInfoEXT,
42178     marker: ::std::marker::PhantomData<&'a ()>,
42179 }
42180 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
42181     for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_>
42182 {
42183 }
42184 unsafe impl ExtendsPipelineRasterizationStateCreateInfo
42185     for PipelineRasterizationLineStateCreateInfoEXT
42186 {
42187 }
42188 impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
42189     type Target = PipelineRasterizationLineStateCreateInfoEXT;
deref(&self) -> &Self::Target42190     fn deref(&self) -> &Self::Target {
42191         &self.inner
42192     }
42193 }
42194 impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42195     fn deref_mut(&mut self) -> &mut Self::Target {
42196         &mut self.inner
42197     }
42198 }
42199 impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
line_rasterization_mode( mut self, line_rasterization_mode: LineRasterizationModeEXT, ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a>42200     pub fn line_rasterization_mode(
42201         mut self,
42202         line_rasterization_mode: LineRasterizationModeEXT,
42203     ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
42204         self.inner.line_rasterization_mode = line_rasterization_mode;
42205         self
42206     }
stippled_line_enable( mut self, stippled_line_enable: bool, ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a>42207     pub fn stippled_line_enable(
42208         mut self,
42209         stippled_line_enable: bool,
42210     ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
42211         self.inner.stippled_line_enable = stippled_line_enable.into();
42212         self
42213     }
line_stipple_factor( mut self, line_stipple_factor: u32, ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a>42214     pub fn line_stipple_factor(
42215         mut self,
42216         line_stipple_factor: u32,
42217     ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
42218         self.inner.line_stipple_factor = line_stipple_factor;
42219         self
42220     }
line_stipple_pattern( mut self, line_stipple_pattern: u16, ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a>42221     pub fn line_stipple_pattern(
42222         mut self,
42223         line_stipple_pattern: u16,
42224     ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
42225         self.inner.line_stipple_pattern = line_stipple_pattern;
42226         self
42227     }
42228     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42229     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42230     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineRasterizationLineStateCreateInfoEXT42231     pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT {
42232         self.inner
42233     }
42234 }
42235 #[repr(C)]
42236 #[derive(Copy, Clone, Debug)]
42237 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT.html>"]
42238 pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
42239     pub s_type: StructureType,
42240     pub p_next: *mut c_void,
42241     pub pipeline_creation_cache_control: Bool32,
42242 }
42243 impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
default() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT42244     fn default() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
42245         PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
42246             s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT,
42247             p_next: ::std::ptr::null_mut(),
42248             pipeline_creation_cache_control: Bool32::default(),
42249         }
42250     }
42251 }
42252 impl PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a>42253     pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
42254         PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder {
42255             inner: PhysicalDevicePipelineCreationCacheControlFeaturesEXT::default(),
42256             marker: ::std::marker::PhantomData,
42257         }
42258     }
42259 }
42260 #[repr(transparent)]
42261 pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
42262     inner: PhysicalDevicePipelineCreationCacheControlFeaturesEXT,
42263     marker: ::std::marker::PhantomData<&'a ()>,
42264 }
42265 unsafe impl ExtendsDeviceCreateInfo
42266     for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'_>
42267 {
42268 }
42269 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeaturesEXT {}
42270 impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
42271     type Target = PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
deref(&self) -> &Self::Target42272     fn deref(&self) -> &Self::Target {
42273         &self.inner
42274     }
42275 }
42276 impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42277     fn deref_mut(&mut self) -> &mut Self::Target {
42278         &mut self.inner
42279     }
42280 }
42281 impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
pipeline_creation_cache_control( mut self, pipeline_creation_cache_control: bool, ) -> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a>42282     pub fn pipeline_creation_cache_control(
42283         mut self,
42284         pipeline_creation_cache_control: bool,
42285     ) -> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
42286         self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
42287         self
42288     }
42289     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42290     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42291     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT42292     pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
42293         self.inner
42294     }
42295 }
42296 #[repr(C)]
42297 #[derive(Copy, Clone, Debug)]
42298 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html>"]
42299 pub struct PhysicalDeviceVulkan11Features {
42300     pub s_type: StructureType,
42301     pub p_next: *mut c_void,
42302     pub storage_buffer16_bit_access: Bool32,
42303     pub uniform_and_storage_buffer16_bit_access: Bool32,
42304     pub storage_push_constant16: Bool32,
42305     pub storage_input_output16: Bool32,
42306     pub multiview: Bool32,
42307     pub multiview_geometry_shader: Bool32,
42308     pub multiview_tessellation_shader: Bool32,
42309     pub variable_pointers_storage_buffer: Bool32,
42310     pub variable_pointers: Bool32,
42311     pub protected_memory: Bool32,
42312     pub sampler_ycbcr_conversion: Bool32,
42313     pub shader_draw_parameters: Bool32,
42314 }
42315 impl ::std::default::Default for PhysicalDeviceVulkan11Features {
default() -> PhysicalDeviceVulkan11Features42316     fn default() -> PhysicalDeviceVulkan11Features {
42317         PhysicalDeviceVulkan11Features {
42318             s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
42319             p_next: ::std::ptr::null_mut(),
42320             storage_buffer16_bit_access: Bool32::default(),
42321             uniform_and_storage_buffer16_bit_access: Bool32::default(),
42322             storage_push_constant16: Bool32::default(),
42323             storage_input_output16: Bool32::default(),
42324             multiview: Bool32::default(),
42325             multiview_geometry_shader: Bool32::default(),
42326             multiview_tessellation_shader: Bool32::default(),
42327             variable_pointers_storage_buffer: Bool32::default(),
42328             variable_pointers: Bool32::default(),
42329             protected_memory: Bool32::default(),
42330             sampler_ycbcr_conversion: Bool32::default(),
42331             shader_draw_parameters: Bool32::default(),
42332         }
42333     }
42334 }
42335 impl PhysicalDeviceVulkan11Features {
builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42336     pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42337         PhysicalDeviceVulkan11FeaturesBuilder {
42338             inner: PhysicalDeviceVulkan11Features::default(),
42339             marker: ::std::marker::PhantomData,
42340         }
42341     }
42342 }
42343 #[repr(transparent)]
42344 pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42345     inner: PhysicalDeviceVulkan11Features,
42346     marker: ::std::marker::PhantomData<&'a ()>,
42347 }
42348 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
42349 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {}
42350 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42351     type Target = PhysicalDeviceVulkan11Features;
deref(&self) -> &Self::Target42352     fn deref(&self) -> &Self::Target {
42353         &self.inner
42354     }
42355 }
42356 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42357     fn deref_mut(&mut self) -> &mut Self::Target {
42358         &mut self.inner
42359     }
42360 }
42361 impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
storage_buffer16_bit_access( mut self, storage_buffer16_bit_access: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42362     pub fn storage_buffer16_bit_access(
42363         mut self,
42364         storage_buffer16_bit_access: bool,
42365     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42366         self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
42367         self
42368     }
uniform_and_storage_buffer16_bit_access( mut self, uniform_and_storage_buffer16_bit_access: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42369     pub fn uniform_and_storage_buffer16_bit_access(
42370         mut self,
42371         uniform_and_storage_buffer16_bit_access: bool,
42372     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42373         self.inner.uniform_and_storage_buffer16_bit_access =
42374             uniform_and_storage_buffer16_bit_access.into();
42375         self
42376     }
storage_push_constant16( mut self, storage_push_constant16: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42377     pub fn storage_push_constant16(
42378         mut self,
42379         storage_push_constant16: bool,
42380     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42381         self.inner.storage_push_constant16 = storage_push_constant16.into();
42382         self
42383     }
storage_input_output16( mut self, storage_input_output16: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42384     pub fn storage_input_output16(
42385         mut self,
42386         storage_input_output16: bool,
42387     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42388         self.inner.storage_input_output16 = storage_input_output16.into();
42389         self
42390     }
multiview(mut self, multiview: bool) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42391     pub fn multiview(mut self, multiview: bool) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42392         self.inner.multiview = multiview.into();
42393         self
42394     }
multiview_geometry_shader( mut self, multiview_geometry_shader: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42395     pub fn multiview_geometry_shader(
42396         mut self,
42397         multiview_geometry_shader: bool,
42398     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42399         self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
42400         self
42401     }
multiview_tessellation_shader( mut self, multiview_tessellation_shader: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42402     pub fn multiview_tessellation_shader(
42403         mut self,
42404         multiview_tessellation_shader: bool,
42405     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42406         self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
42407         self
42408     }
variable_pointers_storage_buffer( mut self, variable_pointers_storage_buffer: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42409     pub fn variable_pointers_storage_buffer(
42410         mut self,
42411         variable_pointers_storage_buffer: bool,
42412     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42413         self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
42414         self
42415     }
variable_pointers( mut self, variable_pointers: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42416     pub fn variable_pointers(
42417         mut self,
42418         variable_pointers: bool,
42419     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42420         self.inner.variable_pointers = variable_pointers.into();
42421         self
42422     }
protected_memory( mut self, protected_memory: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42423     pub fn protected_memory(
42424         mut self,
42425         protected_memory: bool,
42426     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42427         self.inner.protected_memory = protected_memory.into();
42428         self
42429     }
sampler_ycbcr_conversion( mut self, sampler_ycbcr_conversion: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42430     pub fn sampler_ycbcr_conversion(
42431         mut self,
42432         sampler_ycbcr_conversion: bool,
42433     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42434         self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
42435         self
42436     }
shader_draw_parameters( mut self, shader_draw_parameters: bool, ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a>42437     pub fn shader_draw_parameters(
42438         mut self,
42439         shader_draw_parameters: bool,
42440     ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
42441         self.inner.shader_draw_parameters = shader_draw_parameters.into();
42442         self
42443     }
42444     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42445     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42446     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan11Features42447     pub fn build(self) -> PhysicalDeviceVulkan11Features {
42448         self.inner
42449     }
42450 }
42451 #[repr(C)]
42452 #[derive(Copy, Clone, Debug)]
42453 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html>"]
42454 pub struct PhysicalDeviceVulkan11Properties {
42455     pub s_type: StructureType,
42456     pub p_next: *mut c_void,
42457     pub device_uuid: [u8; UUID_SIZE],
42458     pub driver_uuid: [u8; UUID_SIZE],
42459     pub device_luid: [u8; LUID_SIZE],
42460     pub device_node_mask: u32,
42461     pub device_luid_valid: Bool32,
42462     pub subgroup_size: u32,
42463     pub subgroup_supported_stages: ShaderStageFlags,
42464     pub subgroup_supported_operations: SubgroupFeatureFlags,
42465     pub subgroup_quad_operations_in_all_stages: Bool32,
42466     pub point_clipping_behavior: PointClippingBehavior,
42467     pub max_multiview_view_count: u32,
42468     pub max_multiview_instance_index: u32,
42469     pub protected_no_fault: Bool32,
42470     pub max_per_set_descriptors: u32,
42471     pub max_memory_allocation_size: DeviceSize,
42472 }
42473 impl ::std::default::Default for PhysicalDeviceVulkan11Properties {
default() -> PhysicalDeviceVulkan11Properties42474     fn default() -> PhysicalDeviceVulkan11Properties {
42475         PhysicalDeviceVulkan11Properties {
42476             s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
42477             p_next: ::std::ptr::null_mut(),
42478             device_uuid: unsafe { ::std::mem::zeroed() },
42479             driver_uuid: unsafe { ::std::mem::zeroed() },
42480             device_luid: unsafe { ::std::mem::zeroed() },
42481             device_node_mask: u32::default(),
42482             device_luid_valid: Bool32::default(),
42483             subgroup_size: u32::default(),
42484             subgroup_supported_stages: ShaderStageFlags::default(),
42485             subgroup_supported_operations: SubgroupFeatureFlags::default(),
42486             subgroup_quad_operations_in_all_stages: Bool32::default(),
42487             point_clipping_behavior: PointClippingBehavior::default(),
42488             max_multiview_view_count: u32::default(),
42489             max_multiview_instance_index: u32::default(),
42490             protected_no_fault: Bool32::default(),
42491             max_per_set_descriptors: u32::default(),
42492             max_memory_allocation_size: DeviceSize::default(),
42493         }
42494     }
42495 }
42496 impl PhysicalDeviceVulkan11Properties {
builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42497     pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42498         PhysicalDeviceVulkan11PropertiesBuilder {
42499             inner: PhysicalDeviceVulkan11Properties::default(),
42500             marker: ::std::marker::PhantomData,
42501         }
42502     }
42503 }
42504 #[repr(transparent)]
42505 pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42506     inner: PhysicalDeviceVulkan11Properties,
42507     marker: ::std::marker::PhantomData<&'a ()>,
42508 }
42509 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {}
42510 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {}
42511 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42512     type Target = PhysicalDeviceVulkan11Properties;
deref(&self) -> &Self::Target42513     fn deref(&self) -> &Self::Target {
42514         &self.inner
42515     }
42516 }
42517 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42518     fn deref_mut(&mut self) -> &mut Self::Target {
42519         &mut self.inner
42520     }
42521 }
42522 impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
device_uuid( mut self, device_uuid: [u8; UUID_SIZE], ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42523     pub fn device_uuid(
42524         mut self,
42525         device_uuid: [u8; UUID_SIZE],
42526     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42527         self.inner.device_uuid = device_uuid;
42528         self
42529     }
driver_uuid( mut self, driver_uuid: [u8; UUID_SIZE], ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42530     pub fn driver_uuid(
42531         mut self,
42532         driver_uuid: [u8; UUID_SIZE],
42533     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42534         self.inner.driver_uuid = driver_uuid;
42535         self
42536     }
device_luid( mut self, device_luid: [u8; LUID_SIZE], ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42537     pub fn device_luid(
42538         mut self,
42539         device_luid: [u8; LUID_SIZE],
42540     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42541         self.inner.device_luid = device_luid;
42542         self
42543     }
device_node_mask( mut self, device_node_mask: u32, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42544     pub fn device_node_mask(
42545         mut self,
42546         device_node_mask: u32,
42547     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42548         self.inner.device_node_mask = device_node_mask;
42549         self
42550     }
device_luid_valid( mut self, device_luid_valid: bool, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42551     pub fn device_luid_valid(
42552         mut self,
42553         device_luid_valid: bool,
42554     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42555         self.inner.device_luid_valid = device_luid_valid.into();
42556         self
42557     }
subgroup_size( mut self, subgroup_size: u32, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42558     pub fn subgroup_size(
42559         mut self,
42560         subgroup_size: u32,
42561     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42562         self.inner.subgroup_size = subgroup_size;
42563         self
42564     }
subgroup_supported_stages( mut self, subgroup_supported_stages: ShaderStageFlags, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42565     pub fn subgroup_supported_stages(
42566         mut self,
42567         subgroup_supported_stages: ShaderStageFlags,
42568     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42569         self.inner.subgroup_supported_stages = subgroup_supported_stages;
42570         self
42571     }
subgroup_supported_operations( mut self, subgroup_supported_operations: SubgroupFeatureFlags, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42572     pub fn subgroup_supported_operations(
42573         mut self,
42574         subgroup_supported_operations: SubgroupFeatureFlags,
42575     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42576         self.inner.subgroup_supported_operations = subgroup_supported_operations;
42577         self
42578     }
subgroup_quad_operations_in_all_stages( mut self, subgroup_quad_operations_in_all_stages: bool, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42579     pub fn subgroup_quad_operations_in_all_stages(
42580         mut self,
42581         subgroup_quad_operations_in_all_stages: bool,
42582     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42583         self.inner.subgroup_quad_operations_in_all_stages =
42584             subgroup_quad_operations_in_all_stages.into();
42585         self
42586     }
point_clipping_behavior( mut self, point_clipping_behavior: PointClippingBehavior, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42587     pub fn point_clipping_behavior(
42588         mut self,
42589         point_clipping_behavior: PointClippingBehavior,
42590     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42591         self.inner.point_clipping_behavior = point_clipping_behavior;
42592         self
42593     }
max_multiview_view_count( mut self, max_multiview_view_count: u32, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42594     pub fn max_multiview_view_count(
42595         mut self,
42596         max_multiview_view_count: u32,
42597     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42598         self.inner.max_multiview_view_count = max_multiview_view_count;
42599         self
42600     }
max_multiview_instance_index( mut self, max_multiview_instance_index: u32, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42601     pub fn max_multiview_instance_index(
42602         mut self,
42603         max_multiview_instance_index: u32,
42604     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42605         self.inner.max_multiview_instance_index = max_multiview_instance_index;
42606         self
42607     }
protected_no_fault( mut self, protected_no_fault: bool, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42608     pub fn protected_no_fault(
42609         mut self,
42610         protected_no_fault: bool,
42611     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42612         self.inner.protected_no_fault = protected_no_fault.into();
42613         self
42614     }
max_per_set_descriptors( mut self, max_per_set_descriptors: u32, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42615     pub fn max_per_set_descriptors(
42616         mut self,
42617         max_per_set_descriptors: u32,
42618     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42619         self.inner.max_per_set_descriptors = max_per_set_descriptors;
42620         self
42621     }
max_memory_allocation_size( mut self, max_memory_allocation_size: DeviceSize, ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a>42622     pub fn max_memory_allocation_size(
42623         mut self,
42624         max_memory_allocation_size: DeviceSize,
42625     ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
42626         self.inner.max_memory_allocation_size = max_memory_allocation_size;
42627         self
42628     }
42629     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
42630     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
42631     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan11Properties42632     pub fn build(self) -> PhysicalDeviceVulkan11Properties {
42633         self.inner
42634     }
42635 }
42636 #[repr(C)]
42637 #[derive(Copy, Clone, Debug)]
42638 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html>"]
42639 pub struct PhysicalDeviceVulkan12Features {
42640     pub s_type: StructureType,
42641     pub p_next: *mut c_void,
42642     pub sampler_mirror_clamp_to_edge: Bool32,
42643     pub draw_indirect_count: Bool32,
42644     pub storage_buffer8_bit_access: Bool32,
42645     pub uniform_and_storage_buffer8_bit_access: Bool32,
42646     pub storage_push_constant8: Bool32,
42647     pub shader_buffer_int64_atomics: Bool32,
42648     pub shader_shared_int64_atomics: Bool32,
42649     pub shader_float16: Bool32,
42650     pub shader_int8: Bool32,
42651     pub descriptor_indexing: Bool32,
42652     pub shader_input_attachment_array_dynamic_indexing: Bool32,
42653     pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
42654     pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
42655     pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
42656     pub shader_sampled_image_array_non_uniform_indexing: Bool32,
42657     pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
42658     pub shader_storage_image_array_non_uniform_indexing: Bool32,
42659     pub shader_input_attachment_array_non_uniform_indexing: Bool32,
42660     pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
42661     pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
42662     pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
42663     pub descriptor_binding_sampled_image_update_after_bind: Bool32,
42664     pub descriptor_binding_storage_image_update_after_bind: Bool32,
42665     pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
42666     pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
42667     pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
42668     pub descriptor_binding_update_unused_while_pending: Bool32,
42669     pub descriptor_binding_partially_bound: Bool32,
42670     pub descriptor_binding_variable_descriptor_count: Bool32,
42671     pub runtime_descriptor_array: Bool32,
42672     pub sampler_filter_minmax: Bool32,
42673     pub scalar_block_layout: Bool32,
42674     pub imageless_framebuffer: Bool32,
42675     pub uniform_buffer_standard_layout: Bool32,
42676     pub shader_subgroup_extended_types: Bool32,
42677     pub separate_depth_stencil_layouts: Bool32,
42678     pub host_query_reset: Bool32,
42679     pub timeline_semaphore: Bool32,
42680     pub buffer_device_address: Bool32,
42681     pub buffer_device_address_capture_replay: Bool32,
42682     pub buffer_device_address_multi_device: Bool32,
42683     pub vulkan_memory_model: Bool32,
42684     pub vulkan_memory_model_device_scope: Bool32,
42685     pub vulkan_memory_model_availability_visibility_chains: Bool32,
42686     pub shader_output_viewport_index: Bool32,
42687     pub shader_output_layer: Bool32,
42688     pub subgroup_broadcast_dynamic_id: Bool32,
42689 }
42690 impl ::std::default::Default for PhysicalDeviceVulkan12Features {
default() -> PhysicalDeviceVulkan12Features42691     fn default() -> PhysicalDeviceVulkan12Features {
42692         PhysicalDeviceVulkan12Features {
42693             s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
42694             p_next: ::std::ptr::null_mut(),
42695             sampler_mirror_clamp_to_edge: Bool32::default(),
42696             draw_indirect_count: Bool32::default(),
42697             storage_buffer8_bit_access: Bool32::default(),
42698             uniform_and_storage_buffer8_bit_access: Bool32::default(),
42699             storage_push_constant8: Bool32::default(),
42700             shader_buffer_int64_atomics: Bool32::default(),
42701             shader_shared_int64_atomics: Bool32::default(),
42702             shader_float16: Bool32::default(),
42703             shader_int8: Bool32::default(),
42704             descriptor_indexing: Bool32::default(),
42705             shader_input_attachment_array_dynamic_indexing: Bool32::default(),
42706             shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
42707             shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
42708             shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
42709             shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
42710             shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
42711             shader_storage_image_array_non_uniform_indexing: Bool32::default(),
42712             shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
42713             shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
42714             shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
42715             descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
42716             descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
42717             descriptor_binding_storage_image_update_after_bind: Bool32::default(),
42718             descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
42719             descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
42720             descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
42721             descriptor_binding_update_unused_while_pending: Bool32::default(),
42722             descriptor_binding_partially_bound: Bool32::default(),
42723             descriptor_binding_variable_descriptor_count: Bool32::default(),
42724             runtime_descriptor_array: Bool32::default(),
42725             sampler_filter_minmax: Bool32::default(),
42726             scalar_block_layout: Bool32::default(),
42727             imageless_framebuffer: Bool32::default(),
42728             uniform_buffer_standard_layout: Bool32::default(),
42729             shader_subgroup_extended_types: Bool32::default(),
42730             separate_depth_stencil_layouts: Bool32::default(),
42731             host_query_reset: Bool32::default(),
42732             timeline_semaphore: Bool32::default(),
42733             buffer_device_address: Bool32::default(),
42734             buffer_device_address_capture_replay: Bool32::default(),
42735             buffer_device_address_multi_device: Bool32::default(),
42736             vulkan_memory_model: Bool32::default(),
42737             vulkan_memory_model_device_scope: Bool32::default(),
42738             vulkan_memory_model_availability_visibility_chains: Bool32::default(),
42739             shader_output_viewport_index: Bool32::default(),
42740             shader_output_layer: Bool32::default(),
42741             subgroup_broadcast_dynamic_id: Bool32::default(),
42742         }
42743     }
42744 }
42745 impl PhysicalDeviceVulkan12Features {
builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42746     pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42747         PhysicalDeviceVulkan12FeaturesBuilder {
42748             inner: PhysicalDeviceVulkan12Features::default(),
42749             marker: ::std::marker::PhantomData,
42750         }
42751     }
42752 }
42753 #[repr(transparent)]
42754 pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42755     inner: PhysicalDeviceVulkan12Features,
42756     marker: ::std::marker::PhantomData<&'a ()>,
42757 }
42758 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
42759 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {}
42760 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42761     type Target = PhysicalDeviceVulkan12Features;
deref(&self) -> &Self::Target42762     fn deref(&self) -> &Self::Target {
42763         &self.inner
42764     }
42765 }
42766 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target42767     fn deref_mut(&mut self) -> &mut Self::Target {
42768         &mut self.inner
42769     }
42770 }
42771 impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
sampler_mirror_clamp_to_edge( mut self, sampler_mirror_clamp_to_edge: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42772     pub fn sampler_mirror_clamp_to_edge(
42773         mut self,
42774         sampler_mirror_clamp_to_edge: bool,
42775     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42776         self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into();
42777         self
42778     }
draw_indirect_count( mut self, draw_indirect_count: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42779     pub fn draw_indirect_count(
42780         mut self,
42781         draw_indirect_count: bool,
42782     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42783         self.inner.draw_indirect_count = draw_indirect_count.into();
42784         self
42785     }
storage_buffer8_bit_access( mut self, storage_buffer8_bit_access: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42786     pub fn storage_buffer8_bit_access(
42787         mut self,
42788         storage_buffer8_bit_access: bool,
42789     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42790         self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
42791         self
42792     }
uniform_and_storage_buffer8_bit_access( mut self, uniform_and_storage_buffer8_bit_access: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42793     pub fn uniform_and_storage_buffer8_bit_access(
42794         mut self,
42795         uniform_and_storage_buffer8_bit_access: bool,
42796     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42797         self.inner.uniform_and_storage_buffer8_bit_access =
42798             uniform_and_storage_buffer8_bit_access.into();
42799         self
42800     }
storage_push_constant8( mut self, storage_push_constant8: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42801     pub fn storage_push_constant8(
42802         mut self,
42803         storage_push_constant8: bool,
42804     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42805         self.inner.storage_push_constant8 = storage_push_constant8.into();
42806         self
42807     }
shader_buffer_int64_atomics( mut self, shader_buffer_int64_atomics: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42808     pub fn shader_buffer_int64_atomics(
42809         mut self,
42810         shader_buffer_int64_atomics: bool,
42811     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42812         self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
42813         self
42814     }
shader_shared_int64_atomics( mut self, shader_shared_int64_atomics: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42815     pub fn shader_shared_int64_atomics(
42816         mut self,
42817         shader_shared_int64_atomics: bool,
42818     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42819         self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
42820         self
42821     }
shader_float16( mut self, shader_float16: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42822     pub fn shader_float16(
42823         mut self,
42824         shader_float16: bool,
42825     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42826         self.inner.shader_float16 = shader_float16.into();
42827         self
42828     }
shader_int8(mut self, shader_int8: bool) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42829     pub fn shader_int8(mut self, shader_int8: bool) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42830         self.inner.shader_int8 = shader_int8.into();
42831         self
42832     }
descriptor_indexing( mut self, descriptor_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42833     pub fn descriptor_indexing(
42834         mut self,
42835         descriptor_indexing: bool,
42836     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42837         self.inner.descriptor_indexing = descriptor_indexing.into();
42838         self
42839     }
shader_input_attachment_array_dynamic_indexing( mut self, shader_input_attachment_array_dynamic_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42840     pub fn shader_input_attachment_array_dynamic_indexing(
42841         mut self,
42842         shader_input_attachment_array_dynamic_indexing: bool,
42843     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42844         self.inner.shader_input_attachment_array_dynamic_indexing =
42845             shader_input_attachment_array_dynamic_indexing.into();
42846         self
42847     }
shader_uniform_texel_buffer_array_dynamic_indexing( mut self, shader_uniform_texel_buffer_array_dynamic_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42848     pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
42849         mut self,
42850         shader_uniform_texel_buffer_array_dynamic_indexing: bool,
42851     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42852         self.inner
42853             .shader_uniform_texel_buffer_array_dynamic_indexing =
42854             shader_uniform_texel_buffer_array_dynamic_indexing.into();
42855         self
42856     }
shader_storage_texel_buffer_array_dynamic_indexing( mut self, shader_storage_texel_buffer_array_dynamic_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42857     pub fn shader_storage_texel_buffer_array_dynamic_indexing(
42858         mut self,
42859         shader_storage_texel_buffer_array_dynamic_indexing: bool,
42860     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42861         self.inner
42862             .shader_storage_texel_buffer_array_dynamic_indexing =
42863             shader_storage_texel_buffer_array_dynamic_indexing.into();
42864         self
42865     }
shader_uniform_buffer_array_non_uniform_indexing( mut self, shader_uniform_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42866     pub fn shader_uniform_buffer_array_non_uniform_indexing(
42867         mut self,
42868         shader_uniform_buffer_array_non_uniform_indexing: bool,
42869     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42870         self.inner.shader_uniform_buffer_array_non_uniform_indexing =
42871             shader_uniform_buffer_array_non_uniform_indexing.into();
42872         self
42873     }
shader_sampled_image_array_non_uniform_indexing( mut self, shader_sampled_image_array_non_uniform_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42874     pub fn shader_sampled_image_array_non_uniform_indexing(
42875         mut self,
42876         shader_sampled_image_array_non_uniform_indexing: bool,
42877     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42878         self.inner.shader_sampled_image_array_non_uniform_indexing =
42879             shader_sampled_image_array_non_uniform_indexing.into();
42880         self
42881     }
shader_storage_buffer_array_non_uniform_indexing( mut self, shader_storage_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42882     pub fn shader_storage_buffer_array_non_uniform_indexing(
42883         mut self,
42884         shader_storage_buffer_array_non_uniform_indexing: bool,
42885     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42886         self.inner.shader_storage_buffer_array_non_uniform_indexing =
42887             shader_storage_buffer_array_non_uniform_indexing.into();
42888         self
42889     }
shader_storage_image_array_non_uniform_indexing( mut self, shader_storage_image_array_non_uniform_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42890     pub fn shader_storage_image_array_non_uniform_indexing(
42891         mut self,
42892         shader_storage_image_array_non_uniform_indexing: bool,
42893     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42894         self.inner.shader_storage_image_array_non_uniform_indexing =
42895             shader_storage_image_array_non_uniform_indexing.into();
42896         self
42897     }
shader_input_attachment_array_non_uniform_indexing( mut self, shader_input_attachment_array_non_uniform_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42898     pub fn shader_input_attachment_array_non_uniform_indexing(
42899         mut self,
42900         shader_input_attachment_array_non_uniform_indexing: bool,
42901     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42902         self.inner
42903             .shader_input_attachment_array_non_uniform_indexing =
42904             shader_input_attachment_array_non_uniform_indexing.into();
42905         self
42906     }
shader_uniform_texel_buffer_array_non_uniform_indexing( mut self, shader_uniform_texel_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42907     pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
42908         mut self,
42909         shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
42910     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42911         self.inner
42912             .shader_uniform_texel_buffer_array_non_uniform_indexing =
42913             shader_uniform_texel_buffer_array_non_uniform_indexing.into();
42914         self
42915     }
shader_storage_texel_buffer_array_non_uniform_indexing( mut self, shader_storage_texel_buffer_array_non_uniform_indexing: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42916     pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
42917         mut self,
42918         shader_storage_texel_buffer_array_non_uniform_indexing: bool,
42919     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42920         self.inner
42921             .shader_storage_texel_buffer_array_non_uniform_indexing =
42922             shader_storage_texel_buffer_array_non_uniform_indexing.into();
42923         self
42924     }
descriptor_binding_uniform_buffer_update_after_bind( mut self, descriptor_binding_uniform_buffer_update_after_bind: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42925     pub fn descriptor_binding_uniform_buffer_update_after_bind(
42926         mut self,
42927         descriptor_binding_uniform_buffer_update_after_bind: bool,
42928     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42929         self.inner
42930             .descriptor_binding_uniform_buffer_update_after_bind =
42931             descriptor_binding_uniform_buffer_update_after_bind.into();
42932         self
42933     }
descriptor_binding_sampled_image_update_after_bind( mut self, descriptor_binding_sampled_image_update_after_bind: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42934     pub fn descriptor_binding_sampled_image_update_after_bind(
42935         mut self,
42936         descriptor_binding_sampled_image_update_after_bind: bool,
42937     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42938         self.inner
42939             .descriptor_binding_sampled_image_update_after_bind =
42940             descriptor_binding_sampled_image_update_after_bind.into();
42941         self
42942     }
descriptor_binding_storage_image_update_after_bind( mut self, descriptor_binding_storage_image_update_after_bind: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42943     pub fn descriptor_binding_storage_image_update_after_bind(
42944         mut self,
42945         descriptor_binding_storage_image_update_after_bind: bool,
42946     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42947         self.inner
42948             .descriptor_binding_storage_image_update_after_bind =
42949             descriptor_binding_storage_image_update_after_bind.into();
42950         self
42951     }
descriptor_binding_storage_buffer_update_after_bind( mut self, descriptor_binding_storage_buffer_update_after_bind: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42952     pub fn descriptor_binding_storage_buffer_update_after_bind(
42953         mut self,
42954         descriptor_binding_storage_buffer_update_after_bind: bool,
42955     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42956         self.inner
42957             .descriptor_binding_storage_buffer_update_after_bind =
42958             descriptor_binding_storage_buffer_update_after_bind.into();
42959         self
42960     }
descriptor_binding_uniform_texel_buffer_update_after_bind( mut self, descriptor_binding_uniform_texel_buffer_update_after_bind: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42961     pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
42962         mut self,
42963         descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
42964     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42965         self.inner
42966             .descriptor_binding_uniform_texel_buffer_update_after_bind =
42967             descriptor_binding_uniform_texel_buffer_update_after_bind.into();
42968         self
42969     }
descriptor_binding_storage_texel_buffer_update_after_bind( mut self, descriptor_binding_storage_texel_buffer_update_after_bind: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42970     pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
42971         mut self,
42972         descriptor_binding_storage_texel_buffer_update_after_bind: bool,
42973     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42974         self.inner
42975             .descriptor_binding_storage_texel_buffer_update_after_bind =
42976             descriptor_binding_storage_texel_buffer_update_after_bind.into();
42977         self
42978     }
descriptor_binding_update_unused_while_pending( mut self, descriptor_binding_update_unused_while_pending: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42979     pub fn descriptor_binding_update_unused_while_pending(
42980         mut self,
42981         descriptor_binding_update_unused_while_pending: bool,
42982     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42983         self.inner.descriptor_binding_update_unused_while_pending =
42984             descriptor_binding_update_unused_while_pending.into();
42985         self
42986     }
descriptor_binding_partially_bound( mut self, descriptor_binding_partially_bound: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42987     pub fn descriptor_binding_partially_bound(
42988         mut self,
42989         descriptor_binding_partially_bound: bool,
42990     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42991         self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
42992         self
42993     }
descriptor_binding_variable_descriptor_count( mut self, descriptor_binding_variable_descriptor_count: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>42994     pub fn descriptor_binding_variable_descriptor_count(
42995         mut self,
42996         descriptor_binding_variable_descriptor_count: bool,
42997     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
42998         self.inner.descriptor_binding_variable_descriptor_count =
42999             descriptor_binding_variable_descriptor_count.into();
43000         self
43001     }
runtime_descriptor_array( mut self, runtime_descriptor_array: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43002     pub fn runtime_descriptor_array(
43003         mut self,
43004         runtime_descriptor_array: bool,
43005     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43006         self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
43007         self
43008     }
sampler_filter_minmax( mut self, sampler_filter_minmax: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43009     pub fn sampler_filter_minmax(
43010         mut self,
43011         sampler_filter_minmax: bool,
43012     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43013         self.inner.sampler_filter_minmax = sampler_filter_minmax.into();
43014         self
43015     }
scalar_block_layout( mut self, scalar_block_layout: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43016     pub fn scalar_block_layout(
43017         mut self,
43018         scalar_block_layout: bool,
43019     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43020         self.inner.scalar_block_layout = scalar_block_layout.into();
43021         self
43022     }
imageless_framebuffer( mut self, imageless_framebuffer: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43023     pub fn imageless_framebuffer(
43024         mut self,
43025         imageless_framebuffer: bool,
43026     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43027         self.inner.imageless_framebuffer = imageless_framebuffer.into();
43028         self
43029     }
uniform_buffer_standard_layout( mut self, uniform_buffer_standard_layout: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43030     pub fn uniform_buffer_standard_layout(
43031         mut self,
43032         uniform_buffer_standard_layout: bool,
43033     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43034         self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
43035         self
43036     }
shader_subgroup_extended_types( mut self, shader_subgroup_extended_types: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43037     pub fn shader_subgroup_extended_types(
43038         mut self,
43039         shader_subgroup_extended_types: bool,
43040     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43041         self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
43042         self
43043     }
separate_depth_stencil_layouts( mut self, separate_depth_stencil_layouts: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43044     pub fn separate_depth_stencil_layouts(
43045         mut self,
43046         separate_depth_stencil_layouts: bool,
43047     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43048         self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
43049         self
43050     }
host_query_reset( mut self, host_query_reset: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43051     pub fn host_query_reset(
43052         mut self,
43053         host_query_reset: bool,
43054     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43055         self.inner.host_query_reset = host_query_reset.into();
43056         self
43057     }
timeline_semaphore( mut self, timeline_semaphore: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43058     pub fn timeline_semaphore(
43059         mut self,
43060         timeline_semaphore: bool,
43061     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43062         self.inner.timeline_semaphore = timeline_semaphore.into();
43063         self
43064     }
buffer_device_address( mut self, buffer_device_address: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43065     pub fn buffer_device_address(
43066         mut self,
43067         buffer_device_address: bool,
43068     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43069         self.inner.buffer_device_address = buffer_device_address.into();
43070         self
43071     }
buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43072     pub fn buffer_device_address_capture_replay(
43073         mut self,
43074         buffer_device_address_capture_replay: bool,
43075     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43076         self.inner.buffer_device_address_capture_replay =
43077             buffer_device_address_capture_replay.into();
43078         self
43079     }
buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43080     pub fn buffer_device_address_multi_device(
43081         mut self,
43082         buffer_device_address_multi_device: bool,
43083     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43084         self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
43085         self
43086     }
vulkan_memory_model( mut self, vulkan_memory_model: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43087     pub fn vulkan_memory_model(
43088         mut self,
43089         vulkan_memory_model: bool,
43090     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43091         self.inner.vulkan_memory_model = vulkan_memory_model.into();
43092         self
43093     }
vulkan_memory_model_device_scope( mut self, vulkan_memory_model_device_scope: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43094     pub fn vulkan_memory_model_device_scope(
43095         mut self,
43096         vulkan_memory_model_device_scope: bool,
43097     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43098         self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
43099         self
43100     }
vulkan_memory_model_availability_visibility_chains( mut self, vulkan_memory_model_availability_visibility_chains: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43101     pub fn vulkan_memory_model_availability_visibility_chains(
43102         mut self,
43103         vulkan_memory_model_availability_visibility_chains: bool,
43104     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43105         self.inner
43106             .vulkan_memory_model_availability_visibility_chains =
43107             vulkan_memory_model_availability_visibility_chains.into();
43108         self
43109     }
shader_output_viewport_index( mut self, shader_output_viewport_index: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43110     pub fn shader_output_viewport_index(
43111         mut self,
43112         shader_output_viewport_index: bool,
43113     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43114         self.inner.shader_output_viewport_index = shader_output_viewport_index.into();
43115         self
43116     }
shader_output_layer( mut self, shader_output_layer: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43117     pub fn shader_output_layer(
43118         mut self,
43119         shader_output_layer: bool,
43120     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43121         self.inner.shader_output_layer = shader_output_layer.into();
43122         self
43123     }
subgroup_broadcast_dynamic_id( mut self, subgroup_broadcast_dynamic_id: bool, ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a>43124     pub fn subgroup_broadcast_dynamic_id(
43125         mut self,
43126         subgroup_broadcast_dynamic_id: bool,
43127     ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
43128         self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into();
43129         self
43130     }
43131     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43132     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43133     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan12Features43134     pub fn build(self) -> PhysicalDeviceVulkan12Features {
43135         self.inner
43136     }
43137 }
43138 #[repr(C)]
43139 #[derive(Copy, Clone)]
43140 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html>"]
43141 pub struct PhysicalDeviceVulkan12Properties {
43142     pub s_type: StructureType,
43143     pub p_next: *mut c_void,
43144     pub driver_id: DriverId,
43145     pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
43146     pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
43147     pub conformance_version: ConformanceVersion,
43148     pub denorm_behavior_independence: ShaderFloatControlsIndependence,
43149     pub rounding_mode_independence: ShaderFloatControlsIndependence,
43150     pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
43151     pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
43152     pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
43153     pub shader_denorm_preserve_float16: Bool32,
43154     pub shader_denorm_preserve_float32: Bool32,
43155     pub shader_denorm_preserve_float64: Bool32,
43156     pub shader_denorm_flush_to_zero_float16: Bool32,
43157     pub shader_denorm_flush_to_zero_float32: Bool32,
43158     pub shader_denorm_flush_to_zero_float64: Bool32,
43159     pub shader_rounding_mode_rte_float16: Bool32,
43160     pub shader_rounding_mode_rte_float32: Bool32,
43161     pub shader_rounding_mode_rte_float64: Bool32,
43162     pub shader_rounding_mode_rtz_float16: Bool32,
43163     pub shader_rounding_mode_rtz_float32: Bool32,
43164     pub shader_rounding_mode_rtz_float64: Bool32,
43165     pub max_update_after_bind_descriptors_in_all_pools: u32,
43166     pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
43167     pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
43168     pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
43169     pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
43170     pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
43171     pub robust_buffer_access_update_after_bind: Bool32,
43172     pub quad_divergent_implicit_lod: Bool32,
43173     pub max_per_stage_descriptor_update_after_bind_samplers: u32,
43174     pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
43175     pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
43176     pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
43177     pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
43178     pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
43179     pub max_per_stage_update_after_bind_resources: u32,
43180     pub max_descriptor_set_update_after_bind_samplers: u32,
43181     pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
43182     pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
43183     pub max_descriptor_set_update_after_bind_storage_buffers: u32,
43184     pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
43185     pub max_descriptor_set_update_after_bind_sampled_images: u32,
43186     pub max_descriptor_set_update_after_bind_storage_images: u32,
43187     pub max_descriptor_set_update_after_bind_input_attachments: u32,
43188     pub supported_depth_resolve_modes: ResolveModeFlags,
43189     pub supported_stencil_resolve_modes: ResolveModeFlags,
43190     pub independent_resolve_none: Bool32,
43191     pub independent_resolve: Bool32,
43192     pub filter_minmax_single_component_formats: Bool32,
43193     pub filter_minmax_image_component_mapping: Bool32,
43194     pub max_timeline_semaphore_value_difference: u64,
43195     pub framebuffer_integer_color_sample_counts: SampleCountFlags,
43196 }
43197 impl fmt::Debug for PhysicalDeviceVulkan12Properties {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result43198     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
43199         fmt.debug_struct("PhysicalDeviceVulkan12Properties")
43200             .field("s_type", &self.s_type)
43201             .field("p_next", &self.p_next)
43202             .field("driver_id", &self.driver_id)
43203             .field("driver_name", &unsafe {
43204                 ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr() as *const c_char)
43205             })
43206             .field("driver_info", &unsafe {
43207                 ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr() as *const c_char)
43208             })
43209             .field("conformance_version", &self.conformance_version)
43210             .field(
43211                 "denorm_behavior_independence",
43212                 &self.denorm_behavior_independence,
43213             )
43214             .field(
43215                 "rounding_mode_independence",
43216                 &self.rounding_mode_independence,
43217             )
43218             .field(
43219                 "shader_signed_zero_inf_nan_preserve_float16",
43220                 &self.shader_signed_zero_inf_nan_preserve_float16,
43221             )
43222             .field(
43223                 "shader_signed_zero_inf_nan_preserve_float32",
43224                 &self.shader_signed_zero_inf_nan_preserve_float32,
43225             )
43226             .field(
43227                 "shader_signed_zero_inf_nan_preserve_float64",
43228                 &self.shader_signed_zero_inf_nan_preserve_float64,
43229             )
43230             .field(
43231                 "shader_denorm_preserve_float16",
43232                 &self.shader_denorm_preserve_float16,
43233             )
43234             .field(
43235                 "shader_denorm_preserve_float32",
43236                 &self.shader_denorm_preserve_float32,
43237             )
43238             .field(
43239                 "shader_denorm_preserve_float64",
43240                 &self.shader_denorm_preserve_float64,
43241             )
43242             .field(
43243                 "shader_denorm_flush_to_zero_float16",
43244                 &self.shader_denorm_flush_to_zero_float16,
43245             )
43246             .field(
43247                 "shader_denorm_flush_to_zero_float32",
43248                 &self.shader_denorm_flush_to_zero_float32,
43249             )
43250             .field(
43251                 "shader_denorm_flush_to_zero_float64",
43252                 &self.shader_denorm_flush_to_zero_float64,
43253             )
43254             .field(
43255                 "shader_rounding_mode_rte_float16",
43256                 &self.shader_rounding_mode_rte_float16,
43257             )
43258             .field(
43259                 "shader_rounding_mode_rte_float32",
43260                 &self.shader_rounding_mode_rte_float32,
43261             )
43262             .field(
43263                 "shader_rounding_mode_rte_float64",
43264                 &self.shader_rounding_mode_rte_float64,
43265             )
43266             .field(
43267                 "shader_rounding_mode_rtz_float16",
43268                 &self.shader_rounding_mode_rtz_float16,
43269             )
43270             .field(
43271                 "shader_rounding_mode_rtz_float32",
43272                 &self.shader_rounding_mode_rtz_float32,
43273             )
43274             .field(
43275                 "shader_rounding_mode_rtz_float64",
43276                 &self.shader_rounding_mode_rtz_float64,
43277             )
43278             .field(
43279                 "max_update_after_bind_descriptors_in_all_pools",
43280                 &self.max_update_after_bind_descriptors_in_all_pools,
43281             )
43282             .field(
43283                 "shader_uniform_buffer_array_non_uniform_indexing_native",
43284                 &self.shader_uniform_buffer_array_non_uniform_indexing_native,
43285             )
43286             .field(
43287                 "shader_sampled_image_array_non_uniform_indexing_native",
43288                 &self.shader_sampled_image_array_non_uniform_indexing_native,
43289             )
43290             .field(
43291                 "shader_storage_buffer_array_non_uniform_indexing_native",
43292                 &self.shader_storage_buffer_array_non_uniform_indexing_native,
43293             )
43294             .field(
43295                 "shader_storage_image_array_non_uniform_indexing_native",
43296                 &self.shader_storage_image_array_non_uniform_indexing_native,
43297             )
43298             .field(
43299                 "shader_input_attachment_array_non_uniform_indexing_native",
43300                 &self.shader_input_attachment_array_non_uniform_indexing_native,
43301             )
43302             .field(
43303                 "robust_buffer_access_update_after_bind",
43304                 &self.robust_buffer_access_update_after_bind,
43305             )
43306             .field(
43307                 "quad_divergent_implicit_lod",
43308                 &self.quad_divergent_implicit_lod,
43309             )
43310             .field(
43311                 "max_per_stage_descriptor_update_after_bind_samplers",
43312                 &self.max_per_stage_descriptor_update_after_bind_samplers,
43313             )
43314             .field(
43315                 "max_per_stage_descriptor_update_after_bind_uniform_buffers",
43316                 &self.max_per_stage_descriptor_update_after_bind_uniform_buffers,
43317             )
43318             .field(
43319                 "max_per_stage_descriptor_update_after_bind_storage_buffers",
43320                 &self.max_per_stage_descriptor_update_after_bind_storage_buffers,
43321             )
43322             .field(
43323                 "max_per_stage_descriptor_update_after_bind_sampled_images",
43324                 &self.max_per_stage_descriptor_update_after_bind_sampled_images,
43325             )
43326             .field(
43327                 "max_per_stage_descriptor_update_after_bind_storage_images",
43328                 &self.max_per_stage_descriptor_update_after_bind_storage_images,
43329             )
43330             .field(
43331                 "max_per_stage_descriptor_update_after_bind_input_attachments",
43332                 &self.max_per_stage_descriptor_update_after_bind_input_attachments,
43333             )
43334             .field(
43335                 "max_per_stage_update_after_bind_resources",
43336                 &self.max_per_stage_update_after_bind_resources,
43337             )
43338             .field(
43339                 "max_descriptor_set_update_after_bind_samplers",
43340                 &self.max_descriptor_set_update_after_bind_samplers,
43341             )
43342             .field(
43343                 "max_descriptor_set_update_after_bind_uniform_buffers",
43344                 &self.max_descriptor_set_update_after_bind_uniform_buffers,
43345             )
43346             .field(
43347                 "max_descriptor_set_update_after_bind_uniform_buffers_dynamic",
43348                 &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic,
43349             )
43350             .field(
43351                 "max_descriptor_set_update_after_bind_storage_buffers",
43352                 &self.max_descriptor_set_update_after_bind_storage_buffers,
43353             )
43354             .field(
43355                 "max_descriptor_set_update_after_bind_storage_buffers_dynamic",
43356                 &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic,
43357             )
43358             .field(
43359                 "max_descriptor_set_update_after_bind_sampled_images",
43360                 &self.max_descriptor_set_update_after_bind_sampled_images,
43361             )
43362             .field(
43363                 "max_descriptor_set_update_after_bind_storage_images",
43364                 &self.max_descriptor_set_update_after_bind_storage_images,
43365             )
43366             .field(
43367                 "max_descriptor_set_update_after_bind_input_attachments",
43368                 &self.max_descriptor_set_update_after_bind_input_attachments,
43369             )
43370             .field(
43371                 "supported_depth_resolve_modes",
43372                 &self.supported_depth_resolve_modes,
43373             )
43374             .field(
43375                 "supported_stencil_resolve_modes",
43376                 &self.supported_stencil_resolve_modes,
43377             )
43378             .field("independent_resolve_none", &self.independent_resolve_none)
43379             .field("independent_resolve", &self.independent_resolve)
43380             .field(
43381                 "filter_minmax_single_component_formats",
43382                 &self.filter_minmax_single_component_formats,
43383             )
43384             .field(
43385                 "filter_minmax_image_component_mapping",
43386                 &self.filter_minmax_image_component_mapping,
43387             )
43388             .field(
43389                 "max_timeline_semaphore_value_difference",
43390                 &self.max_timeline_semaphore_value_difference,
43391             )
43392             .field(
43393                 "framebuffer_integer_color_sample_counts",
43394                 &self.framebuffer_integer_color_sample_counts,
43395             )
43396             .finish()
43397     }
43398 }
43399 impl ::std::default::Default for PhysicalDeviceVulkan12Properties {
default() -> PhysicalDeviceVulkan12Properties43400     fn default() -> PhysicalDeviceVulkan12Properties {
43401         PhysicalDeviceVulkan12Properties {
43402             s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
43403             p_next: ::std::ptr::null_mut(),
43404             driver_id: DriverId::default(),
43405             driver_name: unsafe { ::std::mem::zeroed() },
43406             driver_info: unsafe { ::std::mem::zeroed() },
43407             conformance_version: ConformanceVersion::default(),
43408             denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
43409             rounding_mode_independence: ShaderFloatControlsIndependence::default(),
43410             shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
43411             shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
43412             shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
43413             shader_denorm_preserve_float16: Bool32::default(),
43414             shader_denorm_preserve_float32: Bool32::default(),
43415             shader_denorm_preserve_float64: Bool32::default(),
43416             shader_denorm_flush_to_zero_float16: Bool32::default(),
43417             shader_denorm_flush_to_zero_float32: Bool32::default(),
43418             shader_denorm_flush_to_zero_float64: Bool32::default(),
43419             shader_rounding_mode_rte_float16: Bool32::default(),
43420             shader_rounding_mode_rte_float32: Bool32::default(),
43421             shader_rounding_mode_rte_float64: Bool32::default(),
43422             shader_rounding_mode_rtz_float16: Bool32::default(),
43423             shader_rounding_mode_rtz_float32: Bool32::default(),
43424             shader_rounding_mode_rtz_float64: Bool32::default(),
43425             max_update_after_bind_descriptors_in_all_pools: u32::default(),
43426             shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
43427             shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
43428             shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
43429             shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
43430             shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
43431             robust_buffer_access_update_after_bind: Bool32::default(),
43432             quad_divergent_implicit_lod: Bool32::default(),
43433             max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
43434             max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
43435             max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
43436             max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
43437             max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
43438             max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
43439             max_per_stage_update_after_bind_resources: u32::default(),
43440             max_descriptor_set_update_after_bind_samplers: u32::default(),
43441             max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
43442             max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
43443             max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
43444             max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
43445             max_descriptor_set_update_after_bind_sampled_images: u32::default(),
43446             max_descriptor_set_update_after_bind_storage_images: u32::default(),
43447             max_descriptor_set_update_after_bind_input_attachments: u32::default(),
43448             supported_depth_resolve_modes: ResolveModeFlags::default(),
43449             supported_stencil_resolve_modes: ResolveModeFlags::default(),
43450             independent_resolve_none: Bool32::default(),
43451             independent_resolve: Bool32::default(),
43452             filter_minmax_single_component_formats: Bool32::default(),
43453             filter_minmax_image_component_mapping: Bool32::default(),
43454             max_timeline_semaphore_value_difference: u64::default(),
43455             framebuffer_integer_color_sample_counts: SampleCountFlags::default(),
43456         }
43457     }
43458 }
43459 impl PhysicalDeviceVulkan12Properties {
builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43460     pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43461         PhysicalDeviceVulkan12PropertiesBuilder {
43462             inner: PhysicalDeviceVulkan12Properties::default(),
43463             marker: ::std::marker::PhantomData,
43464         }
43465     }
43466 }
43467 #[repr(transparent)]
43468 pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43469     inner: PhysicalDeviceVulkan12Properties,
43470     marker: ::std::marker::PhantomData<&'a ()>,
43471 }
43472 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {}
43473 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {}
43474 impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43475     type Target = PhysicalDeviceVulkan12Properties;
deref(&self) -> &Self::Target43476     fn deref(&self) -> &Self::Target {
43477         &self.inner
43478     }
43479 }
43480 impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43481     fn deref_mut(&mut self) -> &mut Self::Target {
43482         &mut self.inner
43483     }
43484 }
43485 impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
driver_id(mut self, driver_id: DriverId) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43486     pub fn driver_id(mut self, driver_id: DriverId) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43487         self.inner.driver_id = driver_id;
43488         self
43489     }
driver_name( mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE], ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43490     pub fn driver_name(
43491         mut self,
43492         driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
43493     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43494         self.inner.driver_name = driver_name;
43495         self
43496     }
driver_info( mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE], ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43497     pub fn driver_info(
43498         mut self,
43499         driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
43500     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43501         self.inner.driver_info = driver_info;
43502         self
43503     }
conformance_version( mut self, conformance_version: ConformanceVersion, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43504     pub fn conformance_version(
43505         mut self,
43506         conformance_version: ConformanceVersion,
43507     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43508         self.inner.conformance_version = conformance_version;
43509         self
43510     }
denorm_behavior_independence( mut self, denorm_behavior_independence: ShaderFloatControlsIndependence, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43511     pub fn denorm_behavior_independence(
43512         mut self,
43513         denorm_behavior_independence: ShaderFloatControlsIndependence,
43514     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43515         self.inner.denorm_behavior_independence = denorm_behavior_independence;
43516         self
43517     }
rounding_mode_independence( mut self, rounding_mode_independence: ShaderFloatControlsIndependence, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43518     pub fn rounding_mode_independence(
43519         mut self,
43520         rounding_mode_independence: ShaderFloatControlsIndependence,
43521     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43522         self.inner.rounding_mode_independence = rounding_mode_independence;
43523         self
43524     }
shader_signed_zero_inf_nan_preserve_float16( mut self, shader_signed_zero_inf_nan_preserve_float16: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43525     pub fn shader_signed_zero_inf_nan_preserve_float16(
43526         mut self,
43527         shader_signed_zero_inf_nan_preserve_float16: bool,
43528     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43529         self.inner.shader_signed_zero_inf_nan_preserve_float16 =
43530             shader_signed_zero_inf_nan_preserve_float16.into();
43531         self
43532     }
shader_signed_zero_inf_nan_preserve_float32( mut self, shader_signed_zero_inf_nan_preserve_float32: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43533     pub fn shader_signed_zero_inf_nan_preserve_float32(
43534         mut self,
43535         shader_signed_zero_inf_nan_preserve_float32: bool,
43536     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43537         self.inner.shader_signed_zero_inf_nan_preserve_float32 =
43538             shader_signed_zero_inf_nan_preserve_float32.into();
43539         self
43540     }
shader_signed_zero_inf_nan_preserve_float64( mut self, shader_signed_zero_inf_nan_preserve_float64: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43541     pub fn shader_signed_zero_inf_nan_preserve_float64(
43542         mut self,
43543         shader_signed_zero_inf_nan_preserve_float64: bool,
43544     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43545         self.inner.shader_signed_zero_inf_nan_preserve_float64 =
43546             shader_signed_zero_inf_nan_preserve_float64.into();
43547         self
43548     }
shader_denorm_preserve_float16( mut self, shader_denorm_preserve_float16: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43549     pub fn shader_denorm_preserve_float16(
43550         mut self,
43551         shader_denorm_preserve_float16: bool,
43552     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43553         self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
43554         self
43555     }
shader_denorm_preserve_float32( mut self, shader_denorm_preserve_float32: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43556     pub fn shader_denorm_preserve_float32(
43557         mut self,
43558         shader_denorm_preserve_float32: bool,
43559     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43560         self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
43561         self
43562     }
shader_denorm_preserve_float64( mut self, shader_denorm_preserve_float64: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43563     pub fn shader_denorm_preserve_float64(
43564         mut self,
43565         shader_denorm_preserve_float64: bool,
43566     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43567         self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
43568         self
43569     }
shader_denorm_flush_to_zero_float16( mut self, shader_denorm_flush_to_zero_float16: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43570     pub fn shader_denorm_flush_to_zero_float16(
43571         mut self,
43572         shader_denorm_flush_to_zero_float16: bool,
43573     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43574         self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
43575         self
43576     }
shader_denorm_flush_to_zero_float32( mut self, shader_denorm_flush_to_zero_float32: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43577     pub fn shader_denorm_flush_to_zero_float32(
43578         mut self,
43579         shader_denorm_flush_to_zero_float32: bool,
43580     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43581         self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
43582         self
43583     }
shader_denorm_flush_to_zero_float64( mut self, shader_denorm_flush_to_zero_float64: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43584     pub fn shader_denorm_flush_to_zero_float64(
43585         mut self,
43586         shader_denorm_flush_to_zero_float64: bool,
43587     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43588         self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
43589         self
43590     }
shader_rounding_mode_rte_float16( mut self, shader_rounding_mode_rte_float16: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43591     pub fn shader_rounding_mode_rte_float16(
43592         mut self,
43593         shader_rounding_mode_rte_float16: bool,
43594     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43595         self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
43596         self
43597     }
shader_rounding_mode_rte_float32( mut self, shader_rounding_mode_rte_float32: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43598     pub fn shader_rounding_mode_rte_float32(
43599         mut self,
43600         shader_rounding_mode_rte_float32: bool,
43601     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43602         self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
43603         self
43604     }
shader_rounding_mode_rte_float64( mut self, shader_rounding_mode_rte_float64: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43605     pub fn shader_rounding_mode_rte_float64(
43606         mut self,
43607         shader_rounding_mode_rte_float64: bool,
43608     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43609         self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
43610         self
43611     }
shader_rounding_mode_rtz_float16( mut self, shader_rounding_mode_rtz_float16: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43612     pub fn shader_rounding_mode_rtz_float16(
43613         mut self,
43614         shader_rounding_mode_rtz_float16: bool,
43615     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43616         self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
43617         self
43618     }
shader_rounding_mode_rtz_float32( mut self, shader_rounding_mode_rtz_float32: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43619     pub fn shader_rounding_mode_rtz_float32(
43620         mut self,
43621         shader_rounding_mode_rtz_float32: bool,
43622     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43623         self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
43624         self
43625     }
shader_rounding_mode_rtz_float64( mut self, shader_rounding_mode_rtz_float64: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43626     pub fn shader_rounding_mode_rtz_float64(
43627         mut self,
43628         shader_rounding_mode_rtz_float64: bool,
43629     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43630         self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
43631         self
43632     }
max_update_after_bind_descriptors_in_all_pools( mut self, max_update_after_bind_descriptors_in_all_pools: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43633     pub fn max_update_after_bind_descriptors_in_all_pools(
43634         mut self,
43635         max_update_after_bind_descriptors_in_all_pools: u32,
43636     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43637         self.inner.max_update_after_bind_descriptors_in_all_pools =
43638             max_update_after_bind_descriptors_in_all_pools;
43639         self
43640     }
shader_uniform_buffer_array_non_uniform_indexing_native( mut self, shader_uniform_buffer_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43641     pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
43642         mut self,
43643         shader_uniform_buffer_array_non_uniform_indexing_native: bool,
43644     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43645         self.inner
43646             .shader_uniform_buffer_array_non_uniform_indexing_native =
43647             shader_uniform_buffer_array_non_uniform_indexing_native.into();
43648         self
43649     }
shader_sampled_image_array_non_uniform_indexing_native( mut self, shader_sampled_image_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43650     pub fn shader_sampled_image_array_non_uniform_indexing_native(
43651         mut self,
43652         shader_sampled_image_array_non_uniform_indexing_native: bool,
43653     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43654         self.inner
43655             .shader_sampled_image_array_non_uniform_indexing_native =
43656             shader_sampled_image_array_non_uniform_indexing_native.into();
43657         self
43658     }
shader_storage_buffer_array_non_uniform_indexing_native( mut self, shader_storage_buffer_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43659     pub fn shader_storage_buffer_array_non_uniform_indexing_native(
43660         mut self,
43661         shader_storage_buffer_array_non_uniform_indexing_native: bool,
43662     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43663         self.inner
43664             .shader_storage_buffer_array_non_uniform_indexing_native =
43665             shader_storage_buffer_array_non_uniform_indexing_native.into();
43666         self
43667     }
shader_storage_image_array_non_uniform_indexing_native( mut self, shader_storage_image_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43668     pub fn shader_storage_image_array_non_uniform_indexing_native(
43669         mut self,
43670         shader_storage_image_array_non_uniform_indexing_native: bool,
43671     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43672         self.inner
43673             .shader_storage_image_array_non_uniform_indexing_native =
43674             shader_storage_image_array_non_uniform_indexing_native.into();
43675         self
43676     }
shader_input_attachment_array_non_uniform_indexing_native( mut self, shader_input_attachment_array_non_uniform_indexing_native: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43677     pub fn shader_input_attachment_array_non_uniform_indexing_native(
43678         mut self,
43679         shader_input_attachment_array_non_uniform_indexing_native: bool,
43680     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43681         self.inner
43682             .shader_input_attachment_array_non_uniform_indexing_native =
43683             shader_input_attachment_array_non_uniform_indexing_native.into();
43684         self
43685     }
robust_buffer_access_update_after_bind( mut self, robust_buffer_access_update_after_bind: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43686     pub fn robust_buffer_access_update_after_bind(
43687         mut self,
43688         robust_buffer_access_update_after_bind: bool,
43689     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43690         self.inner.robust_buffer_access_update_after_bind =
43691             robust_buffer_access_update_after_bind.into();
43692         self
43693     }
quad_divergent_implicit_lod( mut self, quad_divergent_implicit_lod: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43694     pub fn quad_divergent_implicit_lod(
43695         mut self,
43696         quad_divergent_implicit_lod: bool,
43697     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43698         self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
43699         self
43700     }
max_per_stage_descriptor_update_after_bind_samplers( mut self, max_per_stage_descriptor_update_after_bind_samplers: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43701     pub fn max_per_stage_descriptor_update_after_bind_samplers(
43702         mut self,
43703         max_per_stage_descriptor_update_after_bind_samplers: u32,
43704     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43705         self.inner
43706             .max_per_stage_descriptor_update_after_bind_samplers =
43707             max_per_stage_descriptor_update_after_bind_samplers;
43708         self
43709     }
max_per_stage_descriptor_update_after_bind_uniform_buffers( mut self, max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43710     pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
43711         mut self,
43712         max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
43713     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43714         self.inner
43715             .max_per_stage_descriptor_update_after_bind_uniform_buffers =
43716             max_per_stage_descriptor_update_after_bind_uniform_buffers;
43717         self
43718     }
max_per_stage_descriptor_update_after_bind_storage_buffers( mut self, max_per_stage_descriptor_update_after_bind_storage_buffers: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43719     pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
43720         mut self,
43721         max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
43722     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43723         self.inner
43724             .max_per_stage_descriptor_update_after_bind_storage_buffers =
43725             max_per_stage_descriptor_update_after_bind_storage_buffers;
43726         self
43727     }
max_per_stage_descriptor_update_after_bind_sampled_images( mut self, max_per_stage_descriptor_update_after_bind_sampled_images: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43728     pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
43729         mut self,
43730         max_per_stage_descriptor_update_after_bind_sampled_images: u32,
43731     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43732         self.inner
43733             .max_per_stage_descriptor_update_after_bind_sampled_images =
43734             max_per_stage_descriptor_update_after_bind_sampled_images;
43735         self
43736     }
max_per_stage_descriptor_update_after_bind_storage_images( mut self, max_per_stage_descriptor_update_after_bind_storage_images: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43737     pub fn max_per_stage_descriptor_update_after_bind_storage_images(
43738         mut self,
43739         max_per_stage_descriptor_update_after_bind_storage_images: u32,
43740     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43741         self.inner
43742             .max_per_stage_descriptor_update_after_bind_storage_images =
43743             max_per_stage_descriptor_update_after_bind_storage_images;
43744         self
43745     }
max_per_stage_descriptor_update_after_bind_input_attachments( mut self, max_per_stage_descriptor_update_after_bind_input_attachments: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43746     pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
43747         mut self,
43748         max_per_stage_descriptor_update_after_bind_input_attachments: u32,
43749     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43750         self.inner
43751             .max_per_stage_descriptor_update_after_bind_input_attachments =
43752             max_per_stage_descriptor_update_after_bind_input_attachments;
43753         self
43754     }
max_per_stage_update_after_bind_resources( mut self, max_per_stage_update_after_bind_resources: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43755     pub fn max_per_stage_update_after_bind_resources(
43756         mut self,
43757         max_per_stage_update_after_bind_resources: u32,
43758     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43759         self.inner.max_per_stage_update_after_bind_resources =
43760             max_per_stage_update_after_bind_resources;
43761         self
43762     }
max_descriptor_set_update_after_bind_samplers( mut self, max_descriptor_set_update_after_bind_samplers: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43763     pub fn max_descriptor_set_update_after_bind_samplers(
43764         mut self,
43765         max_descriptor_set_update_after_bind_samplers: u32,
43766     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43767         self.inner.max_descriptor_set_update_after_bind_samplers =
43768             max_descriptor_set_update_after_bind_samplers;
43769         self
43770     }
max_descriptor_set_update_after_bind_uniform_buffers( mut self, max_descriptor_set_update_after_bind_uniform_buffers: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43771     pub fn max_descriptor_set_update_after_bind_uniform_buffers(
43772         mut self,
43773         max_descriptor_set_update_after_bind_uniform_buffers: u32,
43774     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43775         self.inner
43776             .max_descriptor_set_update_after_bind_uniform_buffers =
43777             max_descriptor_set_update_after_bind_uniform_buffers;
43778         self
43779     }
max_descriptor_set_update_after_bind_uniform_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43780     pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
43781         mut self,
43782         max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
43783     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43784         self.inner
43785             .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
43786             max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
43787         self
43788     }
max_descriptor_set_update_after_bind_storage_buffers( mut self, max_descriptor_set_update_after_bind_storage_buffers: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43789     pub fn max_descriptor_set_update_after_bind_storage_buffers(
43790         mut self,
43791         max_descriptor_set_update_after_bind_storage_buffers: u32,
43792     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43793         self.inner
43794             .max_descriptor_set_update_after_bind_storage_buffers =
43795             max_descriptor_set_update_after_bind_storage_buffers;
43796         self
43797     }
max_descriptor_set_update_after_bind_storage_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43798     pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
43799         mut self,
43800         max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
43801     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43802         self.inner
43803             .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
43804             max_descriptor_set_update_after_bind_storage_buffers_dynamic;
43805         self
43806     }
max_descriptor_set_update_after_bind_sampled_images( mut self, max_descriptor_set_update_after_bind_sampled_images: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43807     pub fn max_descriptor_set_update_after_bind_sampled_images(
43808         mut self,
43809         max_descriptor_set_update_after_bind_sampled_images: u32,
43810     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43811         self.inner
43812             .max_descriptor_set_update_after_bind_sampled_images =
43813             max_descriptor_set_update_after_bind_sampled_images;
43814         self
43815     }
max_descriptor_set_update_after_bind_storage_images( mut self, max_descriptor_set_update_after_bind_storage_images: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43816     pub fn max_descriptor_set_update_after_bind_storage_images(
43817         mut self,
43818         max_descriptor_set_update_after_bind_storage_images: u32,
43819     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43820         self.inner
43821             .max_descriptor_set_update_after_bind_storage_images =
43822             max_descriptor_set_update_after_bind_storage_images;
43823         self
43824     }
max_descriptor_set_update_after_bind_input_attachments( mut self, max_descriptor_set_update_after_bind_input_attachments: u32, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43825     pub fn max_descriptor_set_update_after_bind_input_attachments(
43826         mut self,
43827         max_descriptor_set_update_after_bind_input_attachments: u32,
43828     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43829         self.inner
43830             .max_descriptor_set_update_after_bind_input_attachments =
43831             max_descriptor_set_update_after_bind_input_attachments;
43832         self
43833     }
supported_depth_resolve_modes( mut self, supported_depth_resolve_modes: ResolveModeFlags, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43834     pub fn supported_depth_resolve_modes(
43835         mut self,
43836         supported_depth_resolve_modes: ResolveModeFlags,
43837     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43838         self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
43839         self
43840     }
supported_stencil_resolve_modes( mut self, supported_stencil_resolve_modes: ResolveModeFlags, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43841     pub fn supported_stencil_resolve_modes(
43842         mut self,
43843         supported_stencil_resolve_modes: ResolveModeFlags,
43844     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43845         self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
43846         self
43847     }
independent_resolve_none( mut self, independent_resolve_none: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43848     pub fn independent_resolve_none(
43849         mut self,
43850         independent_resolve_none: bool,
43851     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43852         self.inner.independent_resolve_none = independent_resolve_none.into();
43853         self
43854     }
independent_resolve( mut self, independent_resolve: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43855     pub fn independent_resolve(
43856         mut self,
43857         independent_resolve: bool,
43858     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43859         self.inner.independent_resolve = independent_resolve.into();
43860         self
43861     }
filter_minmax_single_component_formats( mut self, filter_minmax_single_component_formats: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43862     pub fn filter_minmax_single_component_formats(
43863         mut self,
43864         filter_minmax_single_component_formats: bool,
43865     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43866         self.inner.filter_minmax_single_component_formats =
43867             filter_minmax_single_component_formats.into();
43868         self
43869     }
filter_minmax_image_component_mapping( mut self, filter_minmax_image_component_mapping: bool, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43870     pub fn filter_minmax_image_component_mapping(
43871         mut self,
43872         filter_minmax_image_component_mapping: bool,
43873     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43874         self.inner.filter_minmax_image_component_mapping =
43875             filter_minmax_image_component_mapping.into();
43876         self
43877     }
max_timeline_semaphore_value_difference( mut self, max_timeline_semaphore_value_difference: u64, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43878     pub fn max_timeline_semaphore_value_difference(
43879         mut self,
43880         max_timeline_semaphore_value_difference: u64,
43881     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43882         self.inner.max_timeline_semaphore_value_difference =
43883             max_timeline_semaphore_value_difference;
43884         self
43885     }
framebuffer_integer_color_sample_counts( mut self, framebuffer_integer_color_sample_counts: SampleCountFlags, ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a>43886     pub fn framebuffer_integer_color_sample_counts(
43887         mut self,
43888         framebuffer_integer_color_sample_counts: SampleCountFlags,
43889     ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
43890         self.inner.framebuffer_integer_color_sample_counts =
43891             framebuffer_integer_color_sample_counts;
43892         self
43893     }
43894     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43895     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43896     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceVulkan12Properties43897     pub fn build(self) -> PhysicalDeviceVulkan12Properties {
43898         self.inner
43899     }
43900 }
43901 #[repr(C)]
43902 #[derive(Copy, Clone, Debug)]
43903 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html>"]
43904 pub struct PipelineCompilerControlCreateInfoAMD {
43905     pub s_type: StructureType,
43906     pub p_next: *const c_void,
43907     pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
43908 }
43909 impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD {
default() -> PipelineCompilerControlCreateInfoAMD43910     fn default() -> PipelineCompilerControlCreateInfoAMD {
43911         PipelineCompilerControlCreateInfoAMD {
43912             s_type: StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
43913             p_next: ::std::ptr::null(),
43914             compiler_control_flags: PipelineCompilerControlFlagsAMD::default(),
43915         }
43916     }
43917 }
43918 impl PipelineCompilerControlCreateInfoAMD {
builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a>43919     pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
43920         PipelineCompilerControlCreateInfoAMDBuilder {
43921             inner: PipelineCompilerControlCreateInfoAMD::default(),
43922             marker: ::std::marker::PhantomData,
43923         }
43924     }
43925 }
43926 #[repr(transparent)]
43927 pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> {
43928     inner: PipelineCompilerControlCreateInfoAMD,
43929     marker: ::std::marker::PhantomData<&'a ()>,
43930 }
43931 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
43932 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
43933 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
43934 unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
43935 impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
43936     type Target = PipelineCompilerControlCreateInfoAMD;
deref(&self) -> &Self::Target43937     fn deref(&self) -> &Self::Target {
43938         &self.inner
43939     }
43940 }
43941 impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target43942     fn deref_mut(&mut self) -> &mut Self::Target {
43943         &mut self.inner
43944     }
43945 }
43946 impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
compiler_control_flags( mut self, compiler_control_flags: PipelineCompilerControlFlagsAMD, ) -> PipelineCompilerControlCreateInfoAMDBuilder<'a>43947     pub fn compiler_control_flags(
43948         mut self,
43949         compiler_control_flags: PipelineCompilerControlFlagsAMD,
43950     ) -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
43951         self.inner.compiler_control_flags = compiler_control_flags;
43952         self
43953     }
43954     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
43955     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
43956     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineCompilerControlCreateInfoAMD43957     pub fn build(self) -> PipelineCompilerControlCreateInfoAMD {
43958         self.inner
43959     }
43960 }
43961 #[repr(C)]
43962 #[derive(Copy, Clone, Debug)]
43963 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>"]
43964 pub struct PhysicalDeviceCoherentMemoryFeaturesAMD {
43965     pub s_type: StructureType,
43966     pub p_next: *mut c_void,
43967     pub device_coherent_memory: Bool32,
43968 }
43969 impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD {
default() -> PhysicalDeviceCoherentMemoryFeaturesAMD43970     fn default() -> PhysicalDeviceCoherentMemoryFeaturesAMD {
43971         PhysicalDeviceCoherentMemoryFeaturesAMD {
43972             s_type: StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
43973             p_next: ::std::ptr::null_mut(),
43974             device_coherent_memory: Bool32::default(),
43975         }
43976     }
43977 }
43978 impl PhysicalDeviceCoherentMemoryFeaturesAMD {
builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a>43979     pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
43980         PhysicalDeviceCoherentMemoryFeaturesAMDBuilder {
43981             inner: PhysicalDeviceCoherentMemoryFeaturesAMD::default(),
43982             marker: ::std::marker::PhantomData,
43983         }
43984     }
43985 }
43986 #[repr(transparent)]
43987 pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
43988     inner: PhysicalDeviceCoherentMemoryFeaturesAMD,
43989     marker: ::std::marker::PhantomData<&'a ()>,
43990 }
43991 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
43992 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {}
43993 impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
43994     type Target = PhysicalDeviceCoherentMemoryFeaturesAMD;
deref(&self) -> &Self::Target43995     fn deref(&self) -> &Self::Target {
43996         &self.inner
43997     }
43998 }
43999 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44000     fn deref_mut(&mut self) -> &mut Self::Target {
44001         &mut self.inner
44002     }
44003 }
44004 impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
device_coherent_memory( mut self, device_coherent_memory: bool, ) -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a>44005     pub fn device_coherent_memory(
44006         mut self,
44007         device_coherent_memory: bool,
44008     ) -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
44009         self.inner.device_coherent_memory = device_coherent_memory.into();
44010         self
44011     }
44012     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44013     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44014     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD44015     pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD {
44016         self.inner
44017     }
44018 }
44019 #[repr(C)]
44020 #[derive(Copy, Clone)]
44021 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceToolPropertiesEXT.html>"]
44022 pub struct PhysicalDeviceToolPropertiesEXT {
44023     pub s_type: StructureType,
44024     pub p_next: *mut c_void,
44025     pub name: [c_char; MAX_EXTENSION_NAME_SIZE],
44026     pub version: [c_char; MAX_EXTENSION_NAME_SIZE],
44027     pub purposes: ToolPurposeFlagsEXT,
44028     pub description: [c_char; MAX_DESCRIPTION_SIZE],
44029     pub layer: [c_char; MAX_EXTENSION_NAME_SIZE],
44030 }
44031 impl fmt::Debug for PhysicalDeviceToolPropertiesEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result44032     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44033         fmt.debug_struct("PhysicalDeviceToolPropertiesEXT")
44034             .field("s_type", &self.s_type)
44035             .field("p_next", &self.p_next)
44036             .field("name", &unsafe {
44037                 ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
44038             })
44039             .field("version", &unsafe {
44040                 ::std::ffi::CStr::from_ptr(self.version.as_ptr() as *const c_char)
44041             })
44042             .field("purposes", &self.purposes)
44043             .field("description", &unsafe {
44044                 ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
44045             })
44046             .field("layer", &unsafe {
44047                 ::std::ffi::CStr::from_ptr(self.layer.as_ptr() as *const c_char)
44048             })
44049             .finish()
44050     }
44051 }
44052 impl ::std::default::Default for PhysicalDeviceToolPropertiesEXT {
default() -> PhysicalDeviceToolPropertiesEXT44053     fn default() -> PhysicalDeviceToolPropertiesEXT {
44054         PhysicalDeviceToolPropertiesEXT {
44055             s_type: StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT,
44056             p_next: ::std::ptr::null_mut(),
44057             name: unsafe { ::std::mem::zeroed() },
44058             version: unsafe { ::std::mem::zeroed() },
44059             purposes: ToolPurposeFlagsEXT::default(),
44060             description: unsafe { ::std::mem::zeroed() },
44061             layer: unsafe { ::std::mem::zeroed() },
44062         }
44063     }
44064 }
44065 impl PhysicalDeviceToolPropertiesEXT {
builder<'a>() -> PhysicalDeviceToolPropertiesEXTBuilder<'a>44066     pub fn builder<'a>() -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44067         PhysicalDeviceToolPropertiesEXTBuilder {
44068             inner: PhysicalDeviceToolPropertiesEXT::default(),
44069             marker: ::std::marker::PhantomData,
44070         }
44071     }
44072 }
44073 #[repr(transparent)]
44074 pub struct PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44075     inner: PhysicalDeviceToolPropertiesEXT,
44076     marker: ::std::marker::PhantomData<&'a ()>,
44077 }
44078 pub unsafe trait ExtendsPhysicalDeviceToolPropertiesEXT {}
44079 impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44080     type Target = PhysicalDeviceToolPropertiesEXT;
deref(&self) -> &Self::Target44081     fn deref(&self) -> &Self::Target {
44082         &self.inner
44083     }
44084 }
44085 impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44086     fn deref_mut(&mut self) -> &mut Self::Target {
44087         &mut self.inner
44088     }
44089 }
44090 impl<'a> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
name( mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE], ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a>44091     pub fn name(
44092         mut self,
44093         name: [c_char; MAX_EXTENSION_NAME_SIZE],
44094     ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44095         self.inner.name = name;
44096         self
44097     }
version( mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE], ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a>44098     pub fn version(
44099         mut self,
44100         version: [c_char; MAX_EXTENSION_NAME_SIZE],
44101     ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44102         self.inner.version = version;
44103         self
44104     }
purposes( mut self, purposes: ToolPurposeFlagsEXT, ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a>44105     pub fn purposes(
44106         mut self,
44107         purposes: ToolPurposeFlagsEXT,
44108     ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44109         self.inner.purposes = purposes;
44110         self
44111     }
description( mut self, description: [c_char; MAX_DESCRIPTION_SIZE], ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a>44112     pub fn description(
44113         mut self,
44114         description: [c_char; MAX_DESCRIPTION_SIZE],
44115     ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44116         self.inner.description = description;
44117         self
44118     }
layer( mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE], ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a>44119     pub fn layer(
44120         mut self,
44121         layer: [c_char; MAX_EXTENSION_NAME_SIZE],
44122     ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44123         self.inner.layer = layer;
44124         self
44125     }
44126     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
44127     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
44128     #[doc = r" valid extension structs can be pushed into the chain."]
44129     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
44130     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceToolPropertiesEXT>( mut self, next: &'a mut T, ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a>44131     pub fn push_next<T: ExtendsPhysicalDeviceToolPropertiesEXT>(
44132         mut self,
44133         next: &'a mut T,
44134     ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
44135         unsafe {
44136             let next_ptr = next as *mut T as *mut BaseOutStructure;
44137             let last_next = ptr_chain_iter(next).last().unwrap();
44138             (*last_next).p_next = self.inner.p_next as _;
44139             self.inner.p_next = next_ptr as _;
44140         }
44141         self
44142     }
44143     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44144     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44145     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceToolPropertiesEXT44146     pub fn build(self) -> PhysicalDeviceToolPropertiesEXT {
44147         self.inner
44148     }
44149 }
44150 #[repr(C)]
44151 #[derive(Copy, Clone)]
44152 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html>"]
44153 pub struct SamplerCustomBorderColorCreateInfoEXT {
44154     pub s_type: StructureType,
44155     pub p_next: *const c_void,
44156     pub custom_border_color: ClearColorValue,
44157     pub format: Format,
44158 }
44159 impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result44160     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44161         fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT")
44162             .field("s_type", &self.s_type)
44163             .field("p_next", &self.p_next)
44164             .field("custom_border_color", &"union")
44165             .field("format", &self.format)
44166             .finish()
44167     }
44168 }
44169 impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT {
default() -> SamplerCustomBorderColorCreateInfoEXT44170     fn default() -> SamplerCustomBorderColorCreateInfoEXT {
44171         SamplerCustomBorderColorCreateInfoEXT {
44172             s_type: StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
44173             p_next: ::std::ptr::null(),
44174             custom_border_color: ClearColorValue::default(),
44175             format: Format::default(),
44176         }
44177     }
44178 }
44179 impl SamplerCustomBorderColorCreateInfoEXT {
builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a>44180     pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
44181         SamplerCustomBorderColorCreateInfoEXTBuilder {
44182             inner: SamplerCustomBorderColorCreateInfoEXT::default(),
44183             marker: ::std::marker::PhantomData,
44184         }
44185     }
44186 }
44187 #[repr(transparent)]
44188 pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
44189     inner: SamplerCustomBorderColorCreateInfoEXT,
44190     marker: ::std::marker::PhantomData<&'a ()>,
44191 }
44192 unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {}
44193 unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {}
44194 impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
44195     type Target = SamplerCustomBorderColorCreateInfoEXT;
deref(&self) -> &Self::Target44196     fn deref(&self) -> &Self::Target {
44197         &self.inner
44198     }
44199 }
44200 impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44201     fn deref_mut(&mut self) -> &mut Self::Target {
44202         &mut self.inner
44203     }
44204 }
44205 impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
custom_border_color( mut self, custom_border_color: ClearColorValue, ) -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a>44206     pub fn custom_border_color(
44207         mut self,
44208         custom_border_color: ClearColorValue,
44209     ) -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
44210         self.inner.custom_border_color = custom_border_color;
44211         self
44212     }
format(mut self, format: Format) -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a>44213     pub fn format(mut self, format: Format) -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
44214         self.inner.format = format;
44215         self
44216     }
44217     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44218     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44219     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> SamplerCustomBorderColorCreateInfoEXT44220     pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT {
44221         self.inner
44222     }
44223 }
44224 #[repr(C)]
44225 #[derive(Copy, Clone, Debug)]
44226 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html>"]
44227 pub struct PhysicalDeviceCustomBorderColorPropertiesEXT {
44228     pub s_type: StructureType,
44229     pub p_next: *mut c_void,
44230     pub max_custom_border_color_samplers: u32,
44231 }
44232 impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT {
default() -> PhysicalDeviceCustomBorderColorPropertiesEXT44233     fn default() -> PhysicalDeviceCustomBorderColorPropertiesEXT {
44234         PhysicalDeviceCustomBorderColorPropertiesEXT {
44235             s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
44236             p_next: ::std::ptr::null_mut(),
44237             max_custom_border_color_samplers: u32::default(),
44238         }
44239     }
44240 }
44241 impl PhysicalDeviceCustomBorderColorPropertiesEXT {
builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a>44242     pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
44243         PhysicalDeviceCustomBorderColorPropertiesEXTBuilder {
44244             inner: PhysicalDeviceCustomBorderColorPropertiesEXT::default(),
44245             marker: ::std::marker::PhantomData,
44246         }
44247     }
44248 }
44249 #[repr(transparent)]
44250 pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
44251     inner: PhysicalDeviceCustomBorderColorPropertiesEXT,
44252     marker: ::std::marker::PhantomData<&'a ()>,
44253 }
44254 unsafe impl ExtendsPhysicalDeviceProperties2
44255     for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_>
44256 {
44257 }
44258 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {}
44259 impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
44260     type Target = PhysicalDeviceCustomBorderColorPropertiesEXT;
deref(&self) -> &Self::Target44261     fn deref(&self) -> &Self::Target {
44262         &self.inner
44263     }
44264 }
44265 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44266     fn deref_mut(&mut self) -> &mut Self::Target {
44267         &mut self.inner
44268     }
44269 }
44270 impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
max_custom_border_color_samplers( mut self, max_custom_border_color_samplers: u32, ) -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a>44271     pub fn max_custom_border_color_samplers(
44272         mut self,
44273         max_custom_border_color_samplers: u32,
44274     ) -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
44275         self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers;
44276         self
44277     }
44278     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44279     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44280     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT44281     pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT {
44282         self.inner
44283     }
44284 }
44285 #[repr(C)]
44286 #[derive(Copy, Clone, Debug)]
44287 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html>"]
44288 pub struct PhysicalDeviceCustomBorderColorFeaturesEXT {
44289     pub s_type: StructureType,
44290     pub p_next: *mut c_void,
44291     pub custom_border_colors: Bool32,
44292     pub custom_border_color_without_format: Bool32,
44293 }
44294 impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT {
default() -> PhysicalDeviceCustomBorderColorFeaturesEXT44295     fn default() -> PhysicalDeviceCustomBorderColorFeaturesEXT {
44296         PhysicalDeviceCustomBorderColorFeaturesEXT {
44297             s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
44298             p_next: ::std::ptr::null_mut(),
44299             custom_border_colors: Bool32::default(),
44300             custom_border_color_without_format: Bool32::default(),
44301         }
44302     }
44303 }
44304 impl PhysicalDeviceCustomBorderColorFeaturesEXT {
builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a>44305     pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
44306         PhysicalDeviceCustomBorderColorFeaturesEXTBuilder {
44307             inner: PhysicalDeviceCustomBorderColorFeaturesEXT::default(),
44308             marker: ::std::marker::PhantomData,
44309         }
44310     }
44311 }
44312 #[repr(transparent)]
44313 pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
44314     inner: PhysicalDeviceCustomBorderColorFeaturesEXT,
44315     marker: ::std::marker::PhantomData<&'a ()>,
44316 }
44317 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {}
44318 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {}
44319 impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
44320     type Target = PhysicalDeviceCustomBorderColorFeaturesEXT;
deref(&self) -> &Self::Target44321     fn deref(&self) -> &Self::Target {
44322         &self.inner
44323     }
44324 }
44325 impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44326     fn deref_mut(&mut self) -> &mut Self::Target {
44327         &mut self.inner
44328     }
44329 }
44330 impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
custom_border_colors( mut self, custom_border_colors: bool, ) -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a>44331     pub fn custom_border_colors(
44332         mut self,
44333         custom_border_colors: bool,
44334     ) -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
44335         self.inner.custom_border_colors = custom_border_colors.into();
44336         self
44337     }
custom_border_color_without_format( mut self, custom_border_color_without_format: bool, ) -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a>44338     pub fn custom_border_color_without_format(
44339         mut self,
44340         custom_border_color_without_format: bool,
44341     ) -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
44342         self.inner.custom_border_color_without_format = custom_border_color_without_format.into();
44343         self
44344     }
44345     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44346     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44347     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT44348     pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT {
44349         self.inner
44350     }
44351 }
44352 #[repr(C)]
44353 #[derive(Copy, Clone)]
44354 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceOrHostAddressKHR.html>"]
44355 pub union DeviceOrHostAddressKHR {
44356     pub device_address: DeviceAddress,
44357     pub host_address: *mut c_void,
44358 }
44359 impl ::std::default::Default for DeviceOrHostAddressKHR {
default() -> DeviceOrHostAddressKHR44360     fn default() -> DeviceOrHostAddressKHR {
44361         unsafe { ::std::mem::zeroed() }
44362     }
44363 }
44364 #[repr(C)]
44365 #[derive(Copy, Clone)]
44366 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceOrHostAddressConstKHR.html>"]
44367 pub union DeviceOrHostAddressConstKHR {
44368     pub device_address: DeviceAddress,
44369     pub host_address: *const c_void,
44370 }
44371 impl ::std::default::Default for DeviceOrHostAddressConstKHR {
default() -> DeviceOrHostAddressConstKHR44372     fn default() -> DeviceOrHostAddressConstKHR {
44373         unsafe { ::std::mem::zeroed() }
44374     }
44375 }
44376 #[repr(C)]
44377 #[derive(Copy, Clone)]
44378 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>"]
44379 pub struct AccelerationStructureGeometryTrianglesDataKHR {
44380     pub s_type: StructureType,
44381     pub p_next: *const c_void,
44382     pub vertex_format: Format,
44383     pub vertex_data: DeviceOrHostAddressConstKHR,
44384     pub vertex_stride: DeviceSize,
44385     pub max_vertex: u32,
44386     pub index_type: IndexType,
44387     pub index_data: DeviceOrHostAddressConstKHR,
44388     pub transform_data: DeviceOrHostAddressConstKHR,
44389 }
44390 impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result44391     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44392         fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR")
44393             .field("s_type", &self.s_type)
44394             .field("p_next", &self.p_next)
44395             .field("vertex_format", &self.vertex_format)
44396             .field("vertex_data", &"union")
44397             .field("vertex_stride", &self.vertex_stride)
44398             .field("max_vertex", &self.max_vertex)
44399             .field("index_type", &self.index_type)
44400             .field("index_data", &"union")
44401             .field("transform_data", &"union")
44402             .finish()
44403     }
44404 }
44405 impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR {
default() -> AccelerationStructureGeometryTrianglesDataKHR44406     fn default() -> AccelerationStructureGeometryTrianglesDataKHR {
44407         AccelerationStructureGeometryTrianglesDataKHR {
44408             s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
44409             p_next: ::std::ptr::null(),
44410             vertex_format: Format::default(),
44411             vertex_data: DeviceOrHostAddressConstKHR::default(),
44412             vertex_stride: DeviceSize::default(),
44413             max_vertex: u32::default(),
44414             index_type: IndexType::default(),
44415             index_data: DeviceOrHostAddressConstKHR::default(),
44416             transform_data: DeviceOrHostAddressConstKHR::default(),
44417         }
44418     }
44419 }
44420 impl AccelerationStructureGeometryTrianglesDataKHR {
builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44421     pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44422         AccelerationStructureGeometryTrianglesDataKHRBuilder {
44423             inner: AccelerationStructureGeometryTrianglesDataKHR::default(),
44424             marker: ::std::marker::PhantomData,
44425         }
44426     }
44427 }
44428 #[repr(transparent)]
44429 pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44430     inner: AccelerationStructureGeometryTrianglesDataKHR,
44431     marker: ::std::marker::PhantomData<&'a ()>,
44432 }
44433 pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {}
44434 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44435     type Target = AccelerationStructureGeometryTrianglesDataKHR;
deref(&self) -> &Self::Target44436     fn deref(&self) -> &Self::Target {
44437         &self.inner
44438     }
44439 }
44440 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44441     fn deref_mut(&mut self) -> &mut Self::Target {
44442         &mut self.inner
44443     }
44444 }
44445 impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
vertex_format( mut self, vertex_format: Format, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44446     pub fn vertex_format(
44447         mut self,
44448         vertex_format: Format,
44449     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44450         self.inner.vertex_format = vertex_format;
44451         self
44452     }
vertex_data( mut self, vertex_data: DeviceOrHostAddressConstKHR, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44453     pub fn vertex_data(
44454         mut self,
44455         vertex_data: DeviceOrHostAddressConstKHR,
44456     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44457         self.inner.vertex_data = vertex_data;
44458         self
44459     }
vertex_stride( mut self, vertex_stride: DeviceSize, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44460     pub fn vertex_stride(
44461         mut self,
44462         vertex_stride: DeviceSize,
44463     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44464         self.inner.vertex_stride = vertex_stride;
44465         self
44466     }
max_vertex( mut self, max_vertex: u32, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44467     pub fn max_vertex(
44468         mut self,
44469         max_vertex: u32,
44470     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44471         self.inner.max_vertex = max_vertex;
44472         self
44473     }
index_type( mut self, index_type: IndexType, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44474     pub fn index_type(
44475         mut self,
44476         index_type: IndexType,
44477     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44478         self.inner.index_type = index_type;
44479         self
44480     }
index_data( mut self, index_data: DeviceOrHostAddressConstKHR, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44481     pub fn index_data(
44482         mut self,
44483         index_data: DeviceOrHostAddressConstKHR,
44484     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44485         self.inner.index_data = index_data;
44486         self
44487     }
transform_data( mut self, transform_data: DeviceOrHostAddressConstKHR, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44488     pub fn transform_data(
44489         mut self,
44490         transform_data: DeviceOrHostAddressConstKHR,
44491     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44492         self.inner.transform_data = transform_data;
44493         self
44494     }
44495     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
44496     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
44497     #[doc = r" valid extension structs can be pushed into the chain."]
44498     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
44499     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>44500     pub fn push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>(
44501         mut self,
44502         next: &'a mut T,
44503     ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
44504         unsafe {
44505             let next_ptr = next as *mut T as *mut BaseOutStructure;
44506             let last_next = ptr_chain_iter(next).last().unwrap();
44507             (*last_next).p_next = self.inner.p_next as _;
44508             self.inner.p_next = next_ptr as _;
44509         }
44510         self
44511     }
44512     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44513     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44514     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryTrianglesDataKHR44515     pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR {
44516         self.inner
44517     }
44518 }
44519 #[repr(C)]
44520 #[derive(Copy, Clone)]
44521 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>"]
44522 pub struct AccelerationStructureGeometryAabbsDataKHR {
44523     pub s_type: StructureType,
44524     pub p_next: *const c_void,
44525     pub data: DeviceOrHostAddressConstKHR,
44526     pub stride: DeviceSize,
44527 }
44528 impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result44529     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44530         fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR")
44531             .field("s_type", &self.s_type)
44532             .field("p_next", &self.p_next)
44533             .field("data", &"union")
44534             .field("stride", &self.stride)
44535             .finish()
44536     }
44537 }
44538 impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR {
default() -> AccelerationStructureGeometryAabbsDataKHR44539     fn default() -> AccelerationStructureGeometryAabbsDataKHR {
44540         AccelerationStructureGeometryAabbsDataKHR {
44541             s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
44542             p_next: ::std::ptr::null(),
44543             data: DeviceOrHostAddressConstKHR::default(),
44544             stride: DeviceSize::default(),
44545         }
44546     }
44547 }
44548 impl AccelerationStructureGeometryAabbsDataKHR {
builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a>44549     pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
44550         AccelerationStructureGeometryAabbsDataKHRBuilder {
44551             inner: AccelerationStructureGeometryAabbsDataKHR::default(),
44552             marker: ::std::marker::PhantomData,
44553         }
44554     }
44555 }
44556 #[repr(transparent)]
44557 pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
44558     inner: AccelerationStructureGeometryAabbsDataKHR,
44559     marker: ::std::marker::PhantomData<&'a ()>,
44560 }
44561 pub unsafe trait ExtendsAccelerationStructureGeometryAabbsDataKHR {}
44562 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
44563     type Target = AccelerationStructureGeometryAabbsDataKHR;
deref(&self) -> &Self::Target44564     fn deref(&self) -> &Self::Target {
44565         &self.inner
44566     }
44567 }
44568 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44569     fn deref_mut(&mut self) -> &mut Self::Target {
44570         &mut self.inner
44571     }
44572 }
44573 impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
data( mut self, data: DeviceOrHostAddressConstKHR, ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a>44574     pub fn data(
44575         mut self,
44576         data: DeviceOrHostAddressConstKHR,
44577     ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
44578         self.inner.data = data;
44579         self
44580     }
stride( mut self, stride: DeviceSize, ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a>44581     pub fn stride(
44582         mut self,
44583         stride: DeviceSize,
44584     ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
44585         self.inner.stride = stride;
44586         self
44587     }
44588     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
44589     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
44590     #[doc = r" valid extension structs can be pushed into the chain."]
44591     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
44592     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureGeometryAabbsDataKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a>44593     pub fn push_next<T: ExtendsAccelerationStructureGeometryAabbsDataKHR>(
44594         mut self,
44595         next: &'a mut T,
44596     ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
44597         unsafe {
44598             let next_ptr = next as *mut T as *mut BaseOutStructure;
44599             let last_next = ptr_chain_iter(next).last().unwrap();
44600             (*last_next).p_next = self.inner.p_next as _;
44601             self.inner.p_next = next_ptr as _;
44602         }
44603         self
44604     }
44605     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44606     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44607     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryAabbsDataKHR44608     pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR {
44609         self.inner
44610     }
44611 }
44612 #[repr(C)]
44613 #[derive(Copy, Clone)]
44614 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>"]
44615 pub struct AccelerationStructureGeometryInstancesDataKHR {
44616     pub s_type: StructureType,
44617     pub p_next: *const c_void,
44618     pub array_of_pointers: Bool32,
44619     pub data: DeviceOrHostAddressConstKHR,
44620 }
44621 impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result44622     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44623         fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR")
44624             .field("s_type", &self.s_type)
44625             .field("p_next", &self.p_next)
44626             .field("array_of_pointers", &self.array_of_pointers)
44627             .field("data", &"union")
44628             .finish()
44629     }
44630 }
44631 impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR {
default() -> AccelerationStructureGeometryInstancesDataKHR44632     fn default() -> AccelerationStructureGeometryInstancesDataKHR {
44633         AccelerationStructureGeometryInstancesDataKHR {
44634             s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
44635             p_next: ::std::ptr::null(),
44636             array_of_pointers: Bool32::default(),
44637             data: DeviceOrHostAddressConstKHR::default(),
44638         }
44639     }
44640 }
44641 impl AccelerationStructureGeometryInstancesDataKHR {
builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a>44642     pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
44643         AccelerationStructureGeometryInstancesDataKHRBuilder {
44644             inner: AccelerationStructureGeometryInstancesDataKHR::default(),
44645             marker: ::std::marker::PhantomData,
44646         }
44647     }
44648 }
44649 #[repr(transparent)]
44650 pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
44651     inner: AccelerationStructureGeometryInstancesDataKHR,
44652     marker: ::std::marker::PhantomData<&'a ()>,
44653 }
44654 pub unsafe trait ExtendsAccelerationStructureGeometryInstancesDataKHR {}
44655 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
44656     type Target = AccelerationStructureGeometryInstancesDataKHR;
deref(&self) -> &Self::Target44657     fn deref(&self) -> &Self::Target {
44658         &self.inner
44659     }
44660 }
44661 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44662     fn deref_mut(&mut self) -> &mut Self::Target {
44663         &mut self.inner
44664     }
44665 }
44666 impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
array_of_pointers( mut self, array_of_pointers: bool, ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a>44667     pub fn array_of_pointers(
44668         mut self,
44669         array_of_pointers: bool,
44670     ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
44671         self.inner.array_of_pointers = array_of_pointers.into();
44672         self
44673     }
data( mut self, data: DeviceOrHostAddressConstKHR, ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a>44674     pub fn data(
44675         mut self,
44676         data: DeviceOrHostAddressConstKHR,
44677     ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
44678         self.inner.data = data;
44679         self
44680     }
44681     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
44682     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
44683     #[doc = r" valid extension structs can be pushed into the chain."]
44684     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
44685     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureGeometryInstancesDataKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a>44686     pub fn push_next<T: ExtendsAccelerationStructureGeometryInstancesDataKHR>(
44687         mut self,
44688         next: &'a mut T,
44689     ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
44690         unsafe {
44691             let next_ptr = next as *mut T as *mut BaseOutStructure;
44692             let last_next = ptr_chain_iter(next).last().unwrap();
44693             (*last_next).p_next = self.inner.p_next as _;
44694             self.inner.p_next = next_ptr as _;
44695         }
44696         self
44697     }
44698     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44699     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44700     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryInstancesDataKHR44701     pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR {
44702         self.inner
44703     }
44704 }
44705 #[repr(C)]
44706 #[derive(Copy, Clone)]
44707 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html>"]
44708 pub union AccelerationStructureGeometryDataKHR {
44709     pub triangles: AccelerationStructureGeometryTrianglesDataKHR,
44710     pub aabbs: AccelerationStructureGeometryAabbsDataKHR,
44711     pub instances: AccelerationStructureGeometryInstancesDataKHR,
44712 }
44713 impl ::std::default::Default for AccelerationStructureGeometryDataKHR {
default() -> AccelerationStructureGeometryDataKHR44714     fn default() -> AccelerationStructureGeometryDataKHR {
44715         unsafe { ::std::mem::zeroed() }
44716     }
44717 }
44718 #[repr(C)]
44719 #[derive(Copy, Clone)]
44720 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryKHR.html>"]
44721 pub struct AccelerationStructureGeometryKHR {
44722     pub s_type: StructureType,
44723     pub p_next: *const c_void,
44724     pub geometry_type: GeometryTypeKHR,
44725     pub geometry: AccelerationStructureGeometryDataKHR,
44726     pub flags: GeometryFlagsKHR,
44727 }
44728 impl fmt::Debug for AccelerationStructureGeometryKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result44729     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44730         fmt.debug_struct("AccelerationStructureGeometryKHR")
44731             .field("s_type", &self.s_type)
44732             .field("p_next", &self.p_next)
44733             .field("geometry_type", &self.geometry_type)
44734             .field("geometry", &"union")
44735             .field("flags", &self.flags)
44736             .finish()
44737     }
44738 }
44739 impl ::std::default::Default for AccelerationStructureGeometryKHR {
default() -> AccelerationStructureGeometryKHR44740     fn default() -> AccelerationStructureGeometryKHR {
44741         AccelerationStructureGeometryKHR {
44742             s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR,
44743             p_next: ::std::ptr::null(),
44744             geometry_type: GeometryTypeKHR::default(),
44745             geometry: AccelerationStructureGeometryDataKHR::default(),
44746             flags: GeometryFlagsKHR::default(),
44747         }
44748     }
44749 }
44750 impl AccelerationStructureGeometryKHR {
builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a>44751     pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> {
44752         AccelerationStructureGeometryKHRBuilder {
44753             inner: AccelerationStructureGeometryKHR::default(),
44754             marker: ::std::marker::PhantomData,
44755         }
44756     }
44757 }
44758 #[repr(transparent)]
44759 pub struct AccelerationStructureGeometryKHRBuilder<'a> {
44760     inner: AccelerationStructureGeometryKHR,
44761     marker: ::std::marker::PhantomData<&'a ()>,
44762 }
44763 pub unsafe trait ExtendsAccelerationStructureGeometryKHR {}
44764 impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> {
44765     type Target = AccelerationStructureGeometryKHR;
deref(&self) -> &Self::Target44766     fn deref(&self) -> &Self::Target {
44767         &self.inner
44768     }
44769 }
44770 impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44771     fn deref_mut(&mut self) -> &mut Self::Target {
44772         &mut self.inner
44773     }
44774 }
44775 impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
geometry_type( mut self, geometry_type: GeometryTypeKHR, ) -> AccelerationStructureGeometryKHRBuilder<'a>44776     pub fn geometry_type(
44777         mut self,
44778         geometry_type: GeometryTypeKHR,
44779     ) -> AccelerationStructureGeometryKHRBuilder<'a> {
44780         self.inner.geometry_type = geometry_type;
44781         self
44782     }
geometry( mut self, geometry: AccelerationStructureGeometryDataKHR, ) -> AccelerationStructureGeometryKHRBuilder<'a>44783     pub fn geometry(
44784         mut self,
44785         geometry: AccelerationStructureGeometryDataKHR,
44786     ) -> AccelerationStructureGeometryKHRBuilder<'a> {
44787         self.inner.geometry = geometry;
44788         self
44789     }
flags(mut self, flags: GeometryFlagsKHR) -> AccelerationStructureGeometryKHRBuilder<'a>44790     pub fn flags(mut self, flags: GeometryFlagsKHR) -> AccelerationStructureGeometryKHRBuilder<'a> {
44791         self.inner.flags = flags;
44792         self
44793     }
44794     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
44795     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
44796     #[doc = r" valid extension structs can be pushed into the chain."]
44797     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
44798     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureGeometryKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureGeometryKHRBuilder<'a>44799     pub fn push_next<T: ExtendsAccelerationStructureGeometryKHR>(
44800         mut self,
44801         next: &'a mut T,
44802     ) -> AccelerationStructureGeometryKHRBuilder<'a> {
44803         unsafe {
44804             let next_ptr = next as *mut T as *mut BaseOutStructure;
44805             let last_next = ptr_chain_iter(next).last().unwrap();
44806             (*last_next).p_next = self.inner.p_next as _;
44807             self.inner.p_next = next_ptr as _;
44808         }
44809         self
44810     }
44811     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44812     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44813     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureGeometryKHR44814     pub fn build(self) -> AccelerationStructureGeometryKHR {
44815         self.inner
44816     }
44817 }
44818 #[repr(C)]
44819 #[derive(Copy, Clone)]
44820 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>"]
44821 pub struct AccelerationStructureBuildGeometryInfoKHR {
44822     pub s_type: StructureType,
44823     pub p_next: *const c_void,
44824     pub ty: AccelerationStructureTypeKHR,
44825     pub flags: BuildAccelerationStructureFlagsKHR,
44826     pub mode: BuildAccelerationStructureModeKHR,
44827     pub src_acceleration_structure: AccelerationStructureKHR,
44828     pub dst_acceleration_structure: AccelerationStructureKHR,
44829     pub geometry_count: u32,
44830     pub p_geometries: *const AccelerationStructureGeometryKHR,
44831     pub pp_geometries: *const *const AccelerationStructureGeometryKHR,
44832     pub scratch_data: DeviceOrHostAddressKHR,
44833 }
44834 impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result44835     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
44836         fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR")
44837             .field("s_type", &self.s_type)
44838             .field("p_next", &self.p_next)
44839             .field("ty", &self.ty)
44840             .field("flags", &self.flags)
44841             .field("mode", &self.mode)
44842             .field(
44843                 "src_acceleration_structure",
44844                 &self.src_acceleration_structure,
44845             )
44846             .field(
44847                 "dst_acceleration_structure",
44848                 &self.dst_acceleration_structure,
44849             )
44850             .field("geometry_count", &self.geometry_count)
44851             .field("p_geometries", &self.p_geometries)
44852             .field("pp_geometries", &self.pp_geometries)
44853             .field("scratch_data", &"union")
44854             .finish()
44855     }
44856 }
44857 impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR {
default() -> AccelerationStructureBuildGeometryInfoKHR44858     fn default() -> AccelerationStructureBuildGeometryInfoKHR {
44859         AccelerationStructureBuildGeometryInfoKHR {
44860             s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
44861             p_next: ::std::ptr::null(),
44862             ty: AccelerationStructureTypeKHR::default(),
44863             flags: BuildAccelerationStructureFlagsKHR::default(),
44864             mode: BuildAccelerationStructureModeKHR::default(),
44865             src_acceleration_structure: AccelerationStructureKHR::default(),
44866             dst_acceleration_structure: AccelerationStructureKHR::default(),
44867             geometry_count: u32::default(),
44868             p_geometries: ::std::ptr::null(),
44869             pp_geometries: ::std::ptr::null(),
44870             scratch_data: DeviceOrHostAddressKHR::default(),
44871         }
44872     }
44873 }
44874 impl AccelerationStructureBuildGeometryInfoKHR {
builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44875     pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44876         AccelerationStructureBuildGeometryInfoKHRBuilder {
44877             inner: AccelerationStructureBuildGeometryInfoKHR::default(),
44878             marker: ::std::marker::PhantomData,
44879         }
44880     }
44881 }
44882 #[repr(transparent)]
44883 pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44884     inner: AccelerationStructureBuildGeometryInfoKHR,
44885     marker: ::std::marker::PhantomData<&'a ()>,
44886 }
44887 pub unsafe trait ExtendsAccelerationStructureBuildGeometryInfoKHR {}
44888 impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44889     type Target = AccelerationStructureBuildGeometryInfoKHR;
deref(&self) -> &Self::Target44890     fn deref(&self) -> &Self::Target {
44891         &self.inner
44892     }
44893 }
44894 impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target44895     fn deref_mut(&mut self) -> &mut Self::Target {
44896         &mut self.inner
44897     }
44898 }
44899 impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
ty( mut self, ty: AccelerationStructureTypeKHR, ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44900     pub fn ty(
44901         mut self,
44902         ty: AccelerationStructureTypeKHR,
44903     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44904         self.inner.ty = ty;
44905         self
44906     }
flags( mut self, flags: BuildAccelerationStructureFlagsKHR, ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44907     pub fn flags(
44908         mut self,
44909         flags: BuildAccelerationStructureFlagsKHR,
44910     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44911         self.inner.flags = flags;
44912         self
44913     }
mode( mut self, mode: BuildAccelerationStructureModeKHR, ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44914     pub fn mode(
44915         mut self,
44916         mode: BuildAccelerationStructureModeKHR,
44917     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44918         self.inner.mode = mode;
44919         self
44920     }
src_acceleration_structure( mut self, src_acceleration_structure: AccelerationStructureKHR, ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44921     pub fn src_acceleration_structure(
44922         mut self,
44923         src_acceleration_structure: AccelerationStructureKHR,
44924     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44925         self.inner.src_acceleration_structure = src_acceleration_structure;
44926         self
44927     }
dst_acceleration_structure( mut self, dst_acceleration_structure: AccelerationStructureKHR, ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44928     pub fn dst_acceleration_structure(
44929         mut self,
44930         dst_acceleration_structure: AccelerationStructureKHR,
44931     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44932         self.inner.dst_acceleration_structure = dst_acceleration_structure;
44933         self
44934     }
geometries( mut self, geometries: &'a [AccelerationStructureGeometryKHR], ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44935     pub fn geometries(
44936         mut self,
44937         geometries: &'a [AccelerationStructureGeometryKHR],
44938     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44939         self.inner.geometry_count = geometries.len() as _;
44940         self.inner.p_geometries = geometries.as_ptr();
44941         self
44942     }
geometries_ptrs( mut self, geometries: &'a [*const AccelerationStructureGeometryKHR], ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44943     pub fn geometries_ptrs(
44944         mut self,
44945         geometries: &'a [*const AccelerationStructureGeometryKHR],
44946     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44947         self.inner.geometry_count = geometries.len() as _;
44948         self.inner.pp_geometries = geometries.as_ptr();
44949         self
44950     }
scratch_data( mut self, scratch_data: DeviceOrHostAddressKHR, ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44951     pub fn scratch_data(
44952         mut self,
44953         scratch_data: DeviceOrHostAddressKHR,
44954     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44955         self.inner.scratch_data = scratch_data;
44956         self
44957     }
44958     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
44959     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
44960     #[doc = r" valid extension structs can be pushed into the chain."]
44961     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
44962     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureBuildGeometryInfoKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a>44963     pub fn push_next<T: ExtendsAccelerationStructureBuildGeometryInfoKHR>(
44964         mut self,
44965         next: &'a mut T,
44966     ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
44967         unsafe {
44968             let next_ptr = next as *mut T as *mut BaseOutStructure;
44969             let last_next = ptr_chain_iter(next).last().unwrap();
44970             (*last_next).p_next = self.inner.p_next as _;
44971             self.inner.p_next = next_ptr as _;
44972         }
44973         self
44974     }
44975     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
44976     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
44977     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureBuildGeometryInfoKHR44978     pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR {
44979         self.inner
44980     }
44981 }
44982 #[repr(C)]
44983 #[derive(Copy, Clone, Default, Debug)]
44984 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildRangeInfoKHR.html>"]
44985 pub struct AccelerationStructureBuildRangeInfoKHR {
44986     pub primitive_count: u32,
44987     pub primitive_offset: u32,
44988     pub first_vertex: u32,
44989     pub transform_offset: u32,
44990 }
44991 impl AccelerationStructureBuildRangeInfoKHR {
builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a>44992     pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
44993         AccelerationStructureBuildRangeInfoKHRBuilder {
44994             inner: AccelerationStructureBuildRangeInfoKHR::default(),
44995             marker: ::std::marker::PhantomData,
44996         }
44997     }
44998 }
44999 #[repr(transparent)]
45000 pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
45001     inner: AccelerationStructureBuildRangeInfoKHR,
45002     marker: ::std::marker::PhantomData<&'a ()>,
45003 }
45004 impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
45005     type Target = AccelerationStructureBuildRangeInfoKHR;
deref(&self) -> &Self::Target45006     fn deref(&self) -> &Self::Target {
45007         &self.inner
45008     }
45009 }
45010 impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45011     fn deref_mut(&mut self) -> &mut Self::Target {
45012         &mut self.inner
45013     }
45014 }
45015 impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
primitive_count( mut self, primitive_count: u32, ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a>45016     pub fn primitive_count(
45017         mut self,
45018         primitive_count: u32,
45019     ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
45020         self.inner.primitive_count = primitive_count;
45021         self
45022     }
primitive_offset( mut self, primitive_offset: u32, ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a>45023     pub fn primitive_offset(
45024         mut self,
45025         primitive_offset: u32,
45026     ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
45027         self.inner.primitive_offset = primitive_offset;
45028         self
45029     }
first_vertex( mut self, first_vertex: u32, ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a>45030     pub fn first_vertex(
45031         mut self,
45032         first_vertex: u32,
45033     ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
45034         self.inner.first_vertex = first_vertex;
45035         self
45036     }
transform_offset( mut self, transform_offset: u32, ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a>45037     pub fn transform_offset(
45038         mut self,
45039         transform_offset: u32,
45040     ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
45041         self.inner.transform_offset = transform_offset;
45042         self
45043     }
45044     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45045     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45046     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureBuildRangeInfoKHR45047     pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR {
45048         self.inner
45049     }
45050 }
45051 #[repr(C)]
45052 #[derive(Copy, Clone, Debug)]
45053 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html>"]
45054 pub struct AccelerationStructureCreateInfoKHR {
45055     pub s_type: StructureType,
45056     pub p_next: *const c_void,
45057     pub create_flags: AccelerationStructureCreateFlagsKHR,
45058     pub buffer: Buffer,
45059     pub offset: DeviceSize,
45060     pub size: DeviceSize,
45061     pub ty: AccelerationStructureTypeKHR,
45062     pub device_address: DeviceAddress,
45063 }
45064 impl ::std::default::Default for AccelerationStructureCreateInfoKHR {
default() -> AccelerationStructureCreateInfoKHR45065     fn default() -> AccelerationStructureCreateInfoKHR {
45066         AccelerationStructureCreateInfoKHR {
45067             s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
45068             p_next: ::std::ptr::null(),
45069             create_flags: AccelerationStructureCreateFlagsKHR::default(),
45070             buffer: Buffer::default(),
45071             offset: DeviceSize::default(),
45072             size: DeviceSize::default(),
45073             ty: AccelerationStructureTypeKHR::default(),
45074             device_address: DeviceAddress::default(),
45075         }
45076     }
45077 }
45078 impl AccelerationStructureCreateInfoKHR {
builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a>45079     pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45080         AccelerationStructureCreateInfoKHRBuilder {
45081             inner: AccelerationStructureCreateInfoKHR::default(),
45082             marker: ::std::marker::PhantomData,
45083         }
45084     }
45085 }
45086 #[repr(transparent)]
45087 pub struct AccelerationStructureCreateInfoKHRBuilder<'a> {
45088     inner: AccelerationStructureCreateInfoKHR,
45089     marker: ::std::marker::PhantomData<&'a ()>,
45090 }
45091 pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {}
45092 impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> {
45093     type Target = AccelerationStructureCreateInfoKHR;
deref(&self) -> &Self::Target45094     fn deref(&self) -> &Self::Target {
45095         &self.inner
45096     }
45097 }
45098 impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45099     fn deref_mut(&mut self) -> &mut Self::Target {
45100         &mut self.inner
45101     }
45102 }
45103 impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
create_flags( mut self, create_flags: AccelerationStructureCreateFlagsKHR, ) -> AccelerationStructureCreateInfoKHRBuilder<'a>45104     pub fn create_flags(
45105         mut self,
45106         create_flags: AccelerationStructureCreateFlagsKHR,
45107     ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45108         self.inner.create_flags = create_flags;
45109         self
45110     }
buffer(mut self, buffer: Buffer) -> AccelerationStructureCreateInfoKHRBuilder<'a>45111     pub fn buffer(mut self, buffer: Buffer) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45112         self.inner.buffer = buffer;
45113         self
45114     }
offset(mut self, offset: DeviceSize) -> AccelerationStructureCreateInfoKHRBuilder<'a>45115     pub fn offset(mut self, offset: DeviceSize) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45116         self.inner.offset = offset;
45117         self
45118     }
size(mut self, size: DeviceSize) -> AccelerationStructureCreateInfoKHRBuilder<'a>45119     pub fn size(mut self, size: DeviceSize) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45120         self.inner.size = size;
45121         self
45122     }
ty( mut self, ty: AccelerationStructureTypeKHR, ) -> AccelerationStructureCreateInfoKHRBuilder<'a>45123     pub fn ty(
45124         mut self,
45125         ty: AccelerationStructureTypeKHR,
45126     ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45127         self.inner.ty = ty;
45128         self
45129     }
device_address( mut self, device_address: DeviceAddress, ) -> AccelerationStructureCreateInfoKHRBuilder<'a>45130     pub fn device_address(
45131         mut self,
45132         device_address: DeviceAddress,
45133     ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45134         self.inner.device_address = device_address;
45135         self
45136     }
45137     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45138     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45139     #[doc = r" valid extension structs can be pushed into the chain."]
45140     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45141     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureCreateInfoKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureCreateInfoKHRBuilder<'a>45142     pub fn push_next<T: ExtendsAccelerationStructureCreateInfoKHR>(
45143         mut self,
45144         next: &'a mut T,
45145     ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
45146         unsafe {
45147             let next_ptr = next as *mut T as *mut BaseOutStructure;
45148             let last_next = ptr_chain_iter(next).last().unwrap();
45149             (*last_next).p_next = self.inner.p_next as _;
45150             self.inner.p_next = next_ptr as _;
45151         }
45152         self
45153     }
45154     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45155     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45156     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureCreateInfoKHR45157     pub fn build(self) -> AccelerationStructureCreateInfoKHR {
45158         self.inner
45159     }
45160 }
45161 #[repr(C)]
45162 #[derive(Copy, Clone, Default, Debug)]
45163 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAabbPositionsKHR.html>"]
45164 pub struct AabbPositionsKHR {
45165     pub min_x: f32,
45166     pub min_y: f32,
45167     pub min_z: f32,
45168     pub max_x: f32,
45169     pub max_y: f32,
45170     pub max_z: f32,
45171 }
45172 impl AabbPositionsKHR {
builder<'a>() -> AabbPositionsKHRBuilder<'a>45173     pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> {
45174         AabbPositionsKHRBuilder {
45175             inner: AabbPositionsKHR::default(),
45176             marker: ::std::marker::PhantomData,
45177         }
45178     }
45179 }
45180 #[repr(transparent)]
45181 pub struct AabbPositionsKHRBuilder<'a> {
45182     inner: AabbPositionsKHR,
45183     marker: ::std::marker::PhantomData<&'a ()>,
45184 }
45185 impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> {
45186     type Target = AabbPositionsKHR;
deref(&self) -> &Self::Target45187     fn deref(&self) -> &Self::Target {
45188         &self.inner
45189     }
45190 }
45191 impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45192     fn deref_mut(&mut self) -> &mut Self::Target {
45193         &mut self.inner
45194     }
45195 }
45196 impl<'a> AabbPositionsKHRBuilder<'a> {
min_x(mut self, min_x: f32) -> AabbPositionsKHRBuilder<'a>45197     pub fn min_x(mut self, min_x: f32) -> AabbPositionsKHRBuilder<'a> {
45198         self.inner.min_x = min_x;
45199         self
45200     }
min_y(mut self, min_y: f32) -> AabbPositionsKHRBuilder<'a>45201     pub fn min_y(mut self, min_y: f32) -> AabbPositionsKHRBuilder<'a> {
45202         self.inner.min_y = min_y;
45203         self
45204     }
min_z(mut self, min_z: f32) -> AabbPositionsKHRBuilder<'a>45205     pub fn min_z(mut self, min_z: f32) -> AabbPositionsKHRBuilder<'a> {
45206         self.inner.min_z = min_z;
45207         self
45208     }
max_x(mut self, max_x: f32) -> AabbPositionsKHRBuilder<'a>45209     pub fn max_x(mut self, max_x: f32) -> AabbPositionsKHRBuilder<'a> {
45210         self.inner.max_x = max_x;
45211         self
45212     }
max_y(mut self, max_y: f32) -> AabbPositionsKHRBuilder<'a>45213     pub fn max_y(mut self, max_y: f32) -> AabbPositionsKHRBuilder<'a> {
45214         self.inner.max_y = max_y;
45215         self
45216     }
max_z(mut self, max_z: f32) -> AabbPositionsKHRBuilder<'a>45217     pub fn max_z(mut self, max_z: f32) -> AabbPositionsKHRBuilder<'a> {
45218         self.inner.max_z = max_z;
45219         self
45220     }
45221     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45222     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45223     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AabbPositionsKHR45224     pub fn build(self) -> AabbPositionsKHR {
45225         self.inner
45226     }
45227 }
45228 #[repr(C)]
45229 #[derive(Copy, Clone)]
45230 pub struct TransformMatrixKHR {
45231     pub matrix: [f32; 12],
45232 }
45233 #[repr(C)]
45234 #[derive(Copy, Clone)]
45235 pub union AccelerationStructureReferenceKHR {
45236     pub device_handle: DeviceAddress,
45237     pub host_handle: AccelerationStructureKHR,
45238 }
45239 #[repr(C)]
45240 #[derive(Copy, Clone)]
45241 pub struct AccelerationStructureInstanceKHR {
45242     pub transform: TransformMatrixKHR,
45243     pub instance_custom_index_and_mask: u32,
45244     pub instance_shader_binding_table_record_offset_and_flags: u32,
45245     pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
45246 }
45247 #[repr(C)]
45248 #[derive(Copy, Clone, Debug)]
45249 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>"]
45250 pub struct AccelerationStructureDeviceAddressInfoKHR {
45251     pub s_type: StructureType,
45252     pub p_next: *const c_void,
45253     pub acceleration_structure: AccelerationStructureKHR,
45254 }
45255 impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR {
default() -> AccelerationStructureDeviceAddressInfoKHR45256     fn default() -> AccelerationStructureDeviceAddressInfoKHR {
45257         AccelerationStructureDeviceAddressInfoKHR {
45258             s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
45259             p_next: ::std::ptr::null(),
45260             acceleration_structure: AccelerationStructureKHR::default(),
45261         }
45262     }
45263 }
45264 impl AccelerationStructureDeviceAddressInfoKHR {
builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a>45265     pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
45266         AccelerationStructureDeviceAddressInfoKHRBuilder {
45267             inner: AccelerationStructureDeviceAddressInfoKHR::default(),
45268             marker: ::std::marker::PhantomData,
45269         }
45270     }
45271 }
45272 #[repr(transparent)]
45273 pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
45274     inner: AccelerationStructureDeviceAddressInfoKHR,
45275     marker: ::std::marker::PhantomData<&'a ()>,
45276 }
45277 pub unsafe trait ExtendsAccelerationStructureDeviceAddressInfoKHR {}
45278 impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
45279     type Target = AccelerationStructureDeviceAddressInfoKHR;
deref(&self) -> &Self::Target45280     fn deref(&self) -> &Self::Target {
45281         &self.inner
45282     }
45283 }
45284 impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45285     fn deref_mut(&mut self) -> &mut Self::Target {
45286         &mut self.inner
45287     }
45288 }
45289 impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
acceleration_structure( mut self, acceleration_structure: AccelerationStructureKHR, ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a>45290     pub fn acceleration_structure(
45291         mut self,
45292         acceleration_structure: AccelerationStructureKHR,
45293     ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
45294         self.inner.acceleration_structure = acceleration_structure;
45295         self
45296     }
45297     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45298     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45299     #[doc = r" valid extension structs can be pushed into the chain."]
45300     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45301     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureDeviceAddressInfoKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a>45302     pub fn push_next<T: ExtendsAccelerationStructureDeviceAddressInfoKHR>(
45303         mut self,
45304         next: &'a mut T,
45305     ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
45306         unsafe {
45307             let next_ptr = next as *mut T as *mut BaseOutStructure;
45308             let last_next = ptr_chain_iter(next).last().unwrap();
45309             (*last_next).p_next = self.inner.p_next as _;
45310             self.inner.p_next = next_ptr as _;
45311         }
45312         self
45313     }
45314     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45315     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45316     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureDeviceAddressInfoKHR45317     pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR {
45318         self.inner
45319     }
45320 }
45321 #[repr(C)]
45322 #[derive(Copy, Clone, Debug)]
45323 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureVersionInfoKHR.html>"]
45324 pub struct AccelerationStructureVersionInfoKHR {
45325     pub s_type: StructureType,
45326     pub p_next: *const c_void,
45327     pub p_version_data: *const u8,
45328 }
45329 impl ::std::default::Default for AccelerationStructureVersionInfoKHR {
default() -> AccelerationStructureVersionInfoKHR45330     fn default() -> AccelerationStructureVersionInfoKHR {
45331         AccelerationStructureVersionInfoKHR {
45332             s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR,
45333             p_next: ::std::ptr::null(),
45334             p_version_data: ::std::ptr::null(),
45335         }
45336     }
45337 }
45338 impl AccelerationStructureVersionInfoKHR {
builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a>45339     pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> {
45340         AccelerationStructureVersionInfoKHRBuilder {
45341             inner: AccelerationStructureVersionInfoKHR::default(),
45342             marker: ::std::marker::PhantomData,
45343         }
45344     }
45345 }
45346 #[repr(transparent)]
45347 pub struct AccelerationStructureVersionInfoKHRBuilder<'a> {
45348     inner: AccelerationStructureVersionInfoKHR,
45349     marker: ::std::marker::PhantomData<&'a ()>,
45350 }
45351 pub unsafe trait ExtendsAccelerationStructureVersionInfoKHR {}
45352 impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> {
45353     type Target = AccelerationStructureVersionInfoKHR;
deref(&self) -> &Self::Target45354     fn deref(&self) -> &Self::Target {
45355         &self.inner
45356     }
45357 }
45358 impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45359     fn deref_mut(&mut self) -> &mut Self::Target {
45360         &mut self.inner
45361     }
45362 }
45363 impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> {
version_data( mut self, version_data: &'a [u8; 2 * UUID_SIZE], ) -> AccelerationStructureVersionInfoKHRBuilder<'a>45364     pub fn version_data(
45365         mut self,
45366         version_data: &'a [u8; 2 * UUID_SIZE],
45367     ) -> AccelerationStructureVersionInfoKHRBuilder<'a> {
45368         self.inner.p_version_data = version_data.as_ptr();
45369         self
45370     }
45371     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45372     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45373     #[doc = r" valid extension structs can be pushed into the chain."]
45374     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45375     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureVersionInfoKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureVersionInfoKHRBuilder<'a>45376     pub fn push_next<T: ExtendsAccelerationStructureVersionInfoKHR>(
45377         mut self,
45378         next: &'a mut T,
45379     ) -> AccelerationStructureVersionInfoKHRBuilder<'a> {
45380         unsafe {
45381             let next_ptr = next as *mut T as *mut BaseOutStructure;
45382             let last_next = ptr_chain_iter(next).last().unwrap();
45383             (*last_next).p_next = self.inner.p_next as _;
45384             self.inner.p_next = next_ptr as _;
45385         }
45386         self
45387     }
45388     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45389     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45390     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureVersionInfoKHR45391     pub fn build(self) -> AccelerationStructureVersionInfoKHR {
45392         self.inner
45393     }
45394 }
45395 #[repr(C)]
45396 #[derive(Copy, Clone, Debug)]
45397 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html>"]
45398 pub struct CopyAccelerationStructureInfoKHR {
45399     pub s_type: StructureType,
45400     pub p_next: *const c_void,
45401     pub src: AccelerationStructureKHR,
45402     pub dst: AccelerationStructureKHR,
45403     pub mode: CopyAccelerationStructureModeKHR,
45404 }
45405 impl ::std::default::Default for CopyAccelerationStructureInfoKHR {
default() -> CopyAccelerationStructureInfoKHR45406     fn default() -> CopyAccelerationStructureInfoKHR {
45407         CopyAccelerationStructureInfoKHR {
45408             s_type: StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR,
45409             p_next: ::std::ptr::null(),
45410             src: AccelerationStructureKHR::default(),
45411             dst: AccelerationStructureKHR::default(),
45412             mode: CopyAccelerationStructureModeKHR::default(),
45413         }
45414     }
45415 }
45416 impl CopyAccelerationStructureInfoKHR {
builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a>45417     pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> {
45418         CopyAccelerationStructureInfoKHRBuilder {
45419             inner: CopyAccelerationStructureInfoKHR::default(),
45420             marker: ::std::marker::PhantomData,
45421         }
45422     }
45423 }
45424 #[repr(transparent)]
45425 pub struct CopyAccelerationStructureInfoKHRBuilder<'a> {
45426     inner: CopyAccelerationStructureInfoKHR,
45427     marker: ::std::marker::PhantomData<&'a ()>,
45428 }
45429 pub unsafe trait ExtendsCopyAccelerationStructureInfoKHR {}
45430 impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> {
45431     type Target = CopyAccelerationStructureInfoKHR;
deref(&self) -> &Self::Target45432     fn deref(&self) -> &Self::Target {
45433         &self.inner
45434     }
45435 }
45436 impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45437     fn deref_mut(&mut self) -> &mut Self::Target {
45438         &mut self.inner
45439     }
45440 }
45441 impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
src( mut self, src: AccelerationStructureKHR, ) -> CopyAccelerationStructureInfoKHRBuilder<'a>45442     pub fn src(
45443         mut self,
45444         src: AccelerationStructureKHR,
45445     ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
45446         self.inner.src = src;
45447         self
45448     }
dst( mut self, dst: AccelerationStructureKHR, ) -> CopyAccelerationStructureInfoKHRBuilder<'a>45449     pub fn dst(
45450         mut self,
45451         dst: AccelerationStructureKHR,
45452     ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
45453         self.inner.dst = dst;
45454         self
45455     }
mode( mut self, mode: CopyAccelerationStructureModeKHR, ) -> CopyAccelerationStructureInfoKHRBuilder<'a>45456     pub fn mode(
45457         mut self,
45458         mode: CopyAccelerationStructureModeKHR,
45459     ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
45460         self.inner.mode = mode;
45461         self
45462     }
45463     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45464     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45465     #[doc = r" valid extension structs can be pushed into the chain."]
45466     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45467     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyAccelerationStructureInfoKHR>( mut self, next: &'a mut T, ) -> CopyAccelerationStructureInfoKHRBuilder<'a>45468     pub fn push_next<T: ExtendsCopyAccelerationStructureInfoKHR>(
45469         mut self,
45470         next: &'a mut T,
45471     ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
45472         unsafe {
45473             let next_ptr = next as *mut T as *mut BaseOutStructure;
45474             let last_next = ptr_chain_iter(next).last().unwrap();
45475             (*last_next).p_next = self.inner.p_next as _;
45476             self.inner.p_next = next_ptr as _;
45477         }
45478         self
45479     }
45480     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45481     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45482     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyAccelerationStructureInfoKHR45483     pub fn build(self) -> CopyAccelerationStructureInfoKHR {
45484         self.inner
45485     }
45486 }
45487 #[repr(C)]
45488 #[derive(Copy, Clone)]
45489 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>"]
45490 pub struct CopyAccelerationStructureToMemoryInfoKHR {
45491     pub s_type: StructureType,
45492     pub p_next: *const c_void,
45493     pub src: AccelerationStructureKHR,
45494     pub dst: DeviceOrHostAddressKHR,
45495     pub mode: CopyAccelerationStructureModeKHR,
45496 }
45497 impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result45498     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
45499         fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR")
45500             .field("s_type", &self.s_type)
45501             .field("p_next", &self.p_next)
45502             .field("src", &self.src)
45503             .field("dst", &"union")
45504             .field("mode", &self.mode)
45505             .finish()
45506     }
45507 }
45508 impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR {
default() -> CopyAccelerationStructureToMemoryInfoKHR45509     fn default() -> CopyAccelerationStructureToMemoryInfoKHR {
45510         CopyAccelerationStructureToMemoryInfoKHR {
45511             s_type: StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
45512             p_next: ::std::ptr::null(),
45513             src: AccelerationStructureKHR::default(),
45514             dst: DeviceOrHostAddressKHR::default(),
45515             mode: CopyAccelerationStructureModeKHR::default(),
45516         }
45517     }
45518 }
45519 impl CopyAccelerationStructureToMemoryInfoKHR {
builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a>45520     pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
45521         CopyAccelerationStructureToMemoryInfoKHRBuilder {
45522             inner: CopyAccelerationStructureToMemoryInfoKHR::default(),
45523             marker: ::std::marker::PhantomData,
45524         }
45525     }
45526 }
45527 #[repr(transparent)]
45528 pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
45529     inner: CopyAccelerationStructureToMemoryInfoKHR,
45530     marker: ::std::marker::PhantomData<&'a ()>,
45531 }
45532 pub unsafe trait ExtendsCopyAccelerationStructureToMemoryInfoKHR {}
45533 impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
45534     type Target = CopyAccelerationStructureToMemoryInfoKHR;
deref(&self) -> &Self::Target45535     fn deref(&self) -> &Self::Target {
45536         &self.inner
45537     }
45538 }
45539 impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45540     fn deref_mut(&mut self) -> &mut Self::Target {
45541         &mut self.inner
45542     }
45543 }
45544 impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
src( mut self, src: AccelerationStructureKHR, ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a>45545     pub fn src(
45546         mut self,
45547         src: AccelerationStructureKHR,
45548     ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
45549         self.inner.src = src;
45550         self
45551     }
dst( mut self, dst: DeviceOrHostAddressKHR, ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a>45552     pub fn dst(
45553         mut self,
45554         dst: DeviceOrHostAddressKHR,
45555     ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
45556         self.inner.dst = dst;
45557         self
45558     }
mode( mut self, mode: CopyAccelerationStructureModeKHR, ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a>45559     pub fn mode(
45560         mut self,
45561         mode: CopyAccelerationStructureModeKHR,
45562     ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
45563         self.inner.mode = mode;
45564         self
45565     }
45566     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45567     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45568     #[doc = r" valid extension structs can be pushed into the chain."]
45569     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45570     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyAccelerationStructureToMemoryInfoKHR>( mut self, next: &'a mut T, ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a>45571     pub fn push_next<T: ExtendsCopyAccelerationStructureToMemoryInfoKHR>(
45572         mut self,
45573         next: &'a mut T,
45574     ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
45575         unsafe {
45576             let next_ptr = next as *mut T as *mut BaseOutStructure;
45577             let last_next = ptr_chain_iter(next).last().unwrap();
45578             (*last_next).p_next = self.inner.p_next as _;
45579             self.inner.p_next = next_ptr as _;
45580         }
45581         self
45582     }
45583     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45584     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45585     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyAccelerationStructureToMemoryInfoKHR45586     pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR {
45587         self.inner
45588     }
45589 }
45590 #[repr(C)]
45591 #[derive(Copy, Clone)]
45592 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>"]
45593 pub struct CopyMemoryToAccelerationStructureInfoKHR {
45594     pub s_type: StructureType,
45595     pub p_next: *const c_void,
45596     pub src: DeviceOrHostAddressConstKHR,
45597     pub dst: AccelerationStructureKHR,
45598     pub mode: CopyAccelerationStructureModeKHR,
45599 }
45600 impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR {
fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result45601     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
45602         fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR")
45603             .field("s_type", &self.s_type)
45604             .field("p_next", &self.p_next)
45605             .field("src", &"union")
45606             .field("dst", &self.dst)
45607             .field("mode", &self.mode)
45608             .finish()
45609     }
45610 }
45611 impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR {
default() -> CopyMemoryToAccelerationStructureInfoKHR45612     fn default() -> CopyMemoryToAccelerationStructureInfoKHR {
45613         CopyMemoryToAccelerationStructureInfoKHR {
45614             s_type: StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
45615             p_next: ::std::ptr::null(),
45616             src: DeviceOrHostAddressConstKHR::default(),
45617             dst: AccelerationStructureKHR::default(),
45618             mode: CopyAccelerationStructureModeKHR::default(),
45619         }
45620     }
45621 }
45622 impl CopyMemoryToAccelerationStructureInfoKHR {
builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a>45623     pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
45624         CopyMemoryToAccelerationStructureInfoKHRBuilder {
45625             inner: CopyMemoryToAccelerationStructureInfoKHR::default(),
45626             marker: ::std::marker::PhantomData,
45627         }
45628     }
45629 }
45630 #[repr(transparent)]
45631 pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
45632     inner: CopyMemoryToAccelerationStructureInfoKHR,
45633     marker: ::std::marker::PhantomData<&'a ()>,
45634 }
45635 pub unsafe trait ExtendsCopyMemoryToAccelerationStructureInfoKHR {}
45636 impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
45637     type Target = CopyMemoryToAccelerationStructureInfoKHR;
deref(&self) -> &Self::Target45638     fn deref(&self) -> &Self::Target {
45639         &self.inner
45640     }
45641 }
45642 impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45643     fn deref_mut(&mut self) -> &mut Self::Target {
45644         &mut self.inner
45645     }
45646 }
45647 impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
src( mut self, src: DeviceOrHostAddressConstKHR, ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a>45648     pub fn src(
45649         mut self,
45650         src: DeviceOrHostAddressConstKHR,
45651     ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
45652         self.inner.src = src;
45653         self
45654     }
dst( mut self, dst: AccelerationStructureKHR, ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a>45655     pub fn dst(
45656         mut self,
45657         dst: AccelerationStructureKHR,
45658     ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
45659         self.inner.dst = dst;
45660         self
45661     }
mode( mut self, mode: CopyAccelerationStructureModeKHR, ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a>45662     pub fn mode(
45663         mut self,
45664         mode: CopyAccelerationStructureModeKHR,
45665     ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
45666         self.inner.mode = mode;
45667         self
45668     }
45669     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45670     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45671     #[doc = r" valid extension structs can be pushed into the chain."]
45672     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45673     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyMemoryToAccelerationStructureInfoKHR>( mut self, next: &'a mut T, ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a>45674     pub fn push_next<T: ExtendsCopyMemoryToAccelerationStructureInfoKHR>(
45675         mut self,
45676         next: &'a mut T,
45677     ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
45678         unsafe {
45679             let next_ptr = next as *mut T as *mut BaseOutStructure;
45680             let last_next = ptr_chain_iter(next).last().unwrap();
45681             (*last_next).p_next = self.inner.p_next as _;
45682             self.inner.p_next = next_ptr as _;
45683         }
45684         self
45685     }
45686     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45687     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45688     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyMemoryToAccelerationStructureInfoKHR45689     pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR {
45690         self.inner
45691     }
45692 }
45693 #[repr(C)]
45694 #[derive(Copy, Clone, Debug)]
45695 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>"]
45696 pub struct RayTracingPipelineInterfaceCreateInfoKHR {
45697     pub s_type: StructureType,
45698     pub p_next: *const c_void,
45699     pub max_pipeline_ray_payload_size: u32,
45700     pub max_pipeline_ray_hit_attribute_size: u32,
45701 }
45702 impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR {
default() -> RayTracingPipelineInterfaceCreateInfoKHR45703     fn default() -> RayTracingPipelineInterfaceCreateInfoKHR {
45704         RayTracingPipelineInterfaceCreateInfoKHR {
45705             s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
45706             p_next: ::std::ptr::null(),
45707             max_pipeline_ray_payload_size: u32::default(),
45708             max_pipeline_ray_hit_attribute_size: u32::default(),
45709         }
45710     }
45711 }
45712 impl RayTracingPipelineInterfaceCreateInfoKHR {
builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a>45713     pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
45714         RayTracingPipelineInterfaceCreateInfoKHRBuilder {
45715             inner: RayTracingPipelineInterfaceCreateInfoKHR::default(),
45716             marker: ::std::marker::PhantomData,
45717         }
45718     }
45719 }
45720 #[repr(transparent)]
45721 pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
45722     inner: RayTracingPipelineInterfaceCreateInfoKHR,
45723     marker: ::std::marker::PhantomData<&'a ()>,
45724 }
45725 pub unsafe trait ExtendsRayTracingPipelineInterfaceCreateInfoKHR {}
45726 impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
45727     type Target = RayTracingPipelineInterfaceCreateInfoKHR;
deref(&self) -> &Self::Target45728     fn deref(&self) -> &Self::Target {
45729         &self.inner
45730     }
45731 }
45732 impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45733     fn deref_mut(&mut self) -> &mut Self::Target {
45734         &mut self.inner
45735     }
45736 }
45737 impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
max_pipeline_ray_payload_size( mut self, max_pipeline_ray_payload_size: u32, ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a>45738     pub fn max_pipeline_ray_payload_size(
45739         mut self,
45740         max_pipeline_ray_payload_size: u32,
45741     ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
45742         self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size;
45743         self
45744     }
max_pipeline_ray_hit_attribute_size( mut self, max_pipeline_ray_hit_attribute_size: u32, ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a>45745     pub fn max_pipeline_ray_hit_attribute_size(
45746         mut self,
45747         max_pipeline_ray_hit_attribute_size: u32,
45748     ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
45749         self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size;
45750         self
45751     }
45752     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45753     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45754     #[doc = r" valid extension structs can be pushed into the chain."]
45755     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45756     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsRayTracingPipelineInterfaceCreateInfoKHR>( mut self, next: &'a mut T, ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a>45757     pub fn push_next<T: ExtendsRayTracingPipelineInterfaceCreateInfoKHR>(
45758         mut self,
45759         next: &'a mut T,
45760     ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
45761         unsafe {
45762             let next_ptr = next as *mut T as *mut BaseOutStructure;
45763             let last_next = ptr_chain_iter(next).last().unwrap();
45764             (*last_next).p_next = self.inner.p_next as _;
45765             self.inner.p_next = next_ptr as _;
45766         }
45767         self
45768     }
45769     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45770     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45771     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RayTracingPipelineInterfaceCreateInfoKHR45772     pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR {
45773         self.inner
45774     }
45775 }
45776 #[repr(C)]
45777 #[derive(Copy, Clone, Debug)]
45778 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html>"]
45779 pub struct PipelineLibraryCreateInfoKHR {
45780     pub s_type: StructureType,
45781     pub p_next: *const c_void,
45782     pub library_count: u32,
45783     pub p_libraries: *const Pipeline,
45784 }
45785 impl ::std::default::Default for PipelineLibraryCreateInfoKHR {
default() -> PipelineLibraryCreateInfoKHR45786     fn default() -> PipelineLibraryCreateInfoKHR {
45787         PipelineLibraryCreateInfoKHR {
45788             s_type: StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR,
45789             p_next: ::std::ptr::null(),
45790             library_count: u32::default(),
45791             p_libraries: ::std::ptr::null(),
45792         }
45793     }
45794 }
45795 impl PipelineLibraryCreateInfoKHR {
builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a>45796     pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> {
45797         PipelineLibraryCreateInfoKHRBuilder {
45798             inner: PipelineLibraryCreateInfoKHR::default(),
45799             marker: ::std::marker::PhantomData,
45800         }
45801     }
45802 }
45803 #[repr(transparent)]
45804 pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
45805     inner: PipelineLibraryCreateInfoKHR,
45806     marker: ::std::marker::PhantomData<&'a ()>,
45807 }
45808 pub unsafe trait ExtendsPipelineLibraryCreateInfoKHR {}
45809 impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
45810     type Target = PipelineLibraryCreateInfoKHR;
deref(&self) -> &Self::Target45811     fn deref(&self) -> &Self::Target {
45812         &self.inner
45813     }
45814 }
45815 impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45816     fn deref_mut(&mut self) -> &mut Self::Target {
45817         &mut self.inner
45818     }
45819 }
45820 impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
libraries( mut self, libraries: &'a [Pipeline], ) -> PipelineLibraryCreateInfoKHRBuilder<'a>45821     pub fn libraries(
45822         mut self,
45823         libraries: &'a [Pipeline],
45824     ) -> PipelineLibraryCreateInfoKHRBuilder<'a> {
45825         self.inner.library_count = libraries.len() as _;
45826         self.inner.p_libraries = libraries.as_ptr();
45827         self
45828     }
45829     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
45830     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
45831     #[doc = r" valid extension structs can be pushed into the chain."]
45832     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
45833     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPipelineLibraryCreateInfoKHR>( mut self, next: &'a mut T, ) -> PipelineLibraryCreateInfoKHRBuilder<'a>45834     pub fn push_next<T: ExtendsPipelineLibraryCreateInfoKHR>(
45835         mut self,
45836         next: &'a mut T,
45837     ) -> PipelineLibraryCreateInfoKHRBuilder<'a> {
45838         unsafe {
45839             let next_ptr = next as *mut T as *mut BaseOutStructure;
45840             let last_next = ptr_chain_iter(next).last().unwrap();
45841             (*last_next).p_next = self.inner.p_next as _;
45842             self.inner.p_next = next_ptr as _;
45843         }
45844         self
45845     }
45846     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45847     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45848     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineLibraryCreateInfoKHR45849     pub fn build(self) -> PipelineLibraryCreateInfoKHR {
45850         self.inner
45851     }
45852 }
45853 #[repr(C)]
45854 #[derive(Copy, Clone, Debug)]
45855 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html>"]
45856 pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT {
45857     pub s_type: StructureType,
45858     pub p_next: *mut c_void,
45859     pub extended_dynamic_state: Bool32,
45860 }
45861 impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
default() -> PhysicalDeviceExtendedDynamicStateFeaturesEXT45862     fn default() -> PhysicalDeviceExtendedDynamicStateFeaturesEXT {
45863         PhysicalDeviceExtendedDynamicStateFeaturesEXT {
45864             s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
45865             p_next: ::std::ptr::null_mut(),
45866             extended_dynamic_state: Bool32::default(),
45867         }
45868     }
45869 }
45870 impl PhysicalDeviceExtendedDynamicStateFeaturesEXT {
builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a>45871     pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
45872         PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder {
45873             inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT::default(),
45874             marker: ::std::marker::PhantomData,
45875         }
45876     }
45877 }
45878 #[repr(transparent)]
45879 pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
45880     inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT,
45881     marker: ::std::marker::PhantomData<&'a ()>,
45882 }
45883 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {}
45884 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {}
45885 impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
45886     type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
deref(&self) -> &Self::Target45887     fn deref(&self) -> &Self::Target {
45888         &self.inner
45889     }
45890 }
45891 impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45892     fn deref_mut(&mut self) -> &mut Self::Target {
45893         &mut self.inner
45894     }
45895 }
45896 impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
extended_dynamic_state( mut self, extended_dynamic_state: bool, ) -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a>45897     pub fn extended_dynamic_state(
45898         mut self,
45899         extended_dynamic_state: bool,
45900     ) -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
45901         self.inner.extended_dynamic_state = extended_dynamic_state.into();
45902         self
45903     }
45904     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45905     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45906     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT45907     pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT {
45908         self.inner
45909     }
45910 }
45911 #[repr(C)]
45912 #[derive(Copy, Clone, Debug)]
45913 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html>"]
45914 pub struct RenderPassTransformBeginInfoQCOM {
45915     pub s_type: StructureType,
45916     pub p_next: *mut c_void,
45917     pub transform: SurfaceTransformFlagsKHR,
45918 }
45919 impl ::std::default::Default for RenderPassTransformBeginInfoQCOM {
default() -> RenderPassTransformBeginInfoQCOM45920     fn default() -> RenderPassTransformBeginInfoQCOM {
45921         RenderPassTransformBeginInfoQCOM {
45922             s_type: StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
45923             p_next: ::std::ptr::null_mut(),
45924             transform: SurfaceTransformFlagsKHR::default(),
45925         }
45926     }
45927 }
45928 impl RenderPassTransformBeginInfoQCOM {
builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a>45929     pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
45930         RenderPassTransformBeginInfoQCOMBuilder {
45931             inner: RenderPassTransformBeginInfoQCOM::default(),
45932             marker: ::std::marker::PhantomData,
45933         }
45934     }
45935 }
45936 #[repr(transparent)]
45937 pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> {
45938     inner: RenderPassTransformBeginInfoQCOM,
45939     marker: ::std::marker::PhantomData<&'a ()>,
45940 }
45941 unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {}
45942 unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {}
45943 impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> {
45944     type Target = RenderPassTransformBeginInfoQCOM;
deref(&self) -> &Self::Target45945     fn deref(&self) -> &Self::Target {
45946         &self.inner
45947     }
45948 }
45949 impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target45950     fn deref_mut(&mut self) -> &mut Self::Target {
45951         &mut self.inner
45952     }
45953 }
45954 impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
transform( mut self, transform: SurfaceTransformFlagsKHR, ) -> RenderPassTransformBeginInfoQCOMBuilder<'a>45955     pub fn transform(
45956         mut self,
45957         transform: SurfaceTransformFlagsKHR,
45958     ) -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
45959         self.inner.transform = transform;
45960         self
45961     }
45962     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
45963     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
45964     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> RenderPassTransformBeginInfoQCOM45965     pub fn build(self) -> RenderPassTransformBeginInfoQCOM {
45966         self.inner
45967     }
45968 }
45969 #[repr(C)]
45970 #[derive(Copy, Clone, Debug)]
45971 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyCommandTransformInfoQCOM.html>"]
45972 pub struct CopyCommandTransformInfoQCOM {
45973     pub s_type: StructureType,
45974     pub p_next: *const c_void,
45975     pub transform: SurfaceTransformFlagsKHR,
45976 }
45977 impl ::std::default::Default for CopyCommandTransformInfoQCOM {
default() -> CopyCommandTransformInfoQCOM45978     fn default() -> CopyCommandTransformInfoQCOM {
45979         CopyCommandTransformInfoQCOM {
45980             s_type: StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM,
45981             p_next: ::std::ptr::null(),
45982             transform: SurfaceTransformFlagsKHR::default(),
45983         }
45984     }
45985 }
45986 impl CopyCommandTransformInfoQCOM {
builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a>45987     pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> {
45988         CopyCommandTransformInfoQCOMBuilder {
45989             inner: CopyCommandTransformInfoQCOM::default(),
45990             marker: ::std::marker::PhantomData,
45991         }
45992     }
45993 }
45994 #[repr(transparent)]
45995 pub struct CopyCommandTransformInfoQCOMBuilder<'a> {
45996     inner: CopyCommandTransformInfoQCOM,
45997     marker: ::std::marker::PhantomData<&'a ()>,
45998 }
45999 unsafe impl ExtendsBufferImageCopy2KHR for CopyCommandTransformInfoQCOMBuilder<'_> {}
46000 unsafe impl ExtendsBufferImageCopy2KHR for CopyCommandTransformInfoQCOM {}
46001 unsafe impl ExtendsImageBlit2KHR for CopyCommandTransformInfoQCOMBuilder<'_> {}
46002 unsafe impl ExtendsImageBlit2KHR for CopyCommandTransformInfoQCOM {}
46003 impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> {
46004     type Target = CopyCommandTransformInfoQCOM;
deref(&self) -> &Self::Target46005     fn deref(&self) -> &Self::Target {
46006         &self.inner
46007     }
46008 }
46009 impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46010     fn deref_mut(&mut self) -> &mut Self::Target {
46011         &mut self.inner
46012     }
46013 }
46014 impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> {
transform( mut self, transform: SurfaceTransformFlagsKHR, ) -> CopyCommandTransformInfoQCOMBuilder<'a>46015     pub fn transform(
46016         mut self,
46017         transform: SurfaceTransformFlagsKHR,
46018     ) -> CopyCommandTransformInfoQCOMBuilder<'a> {
46019         self.inner.transform = transform;
46020         self
46021     }
46022     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46023     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46024     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyCommandTransformInfoQCOM46025     pub fn build(self) -> CopyCommandTransformInfoQCOM {
46026         self.inner
46027     }
46028 }
46029 #[repr(C)]
46030 #[derive(Copy, Clone, Debug)]
46031 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>"]
46032 pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
46033     pub s_type: StructureType,
46034     pub p_next: *mut c_void,
46035     pub transform: SurfaceTransformFlagsKHR,
46036     pub render_area: Rect2D,
46037 }
46038 impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM {
default() -> CommandBufferInheritanceRenderPassTransformInfoQCOM46039     fn default() -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
46040         CommandBufferInheritanceRenderPassTransformInfoQCOM {
46041             s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
46042             p_next: ::std::ptr::null_mut(),
46043             transform: SurfaceTransformFlagsKHR::default(),
46044             render_area: Rect2D::default(),
46045         }
46046     }
46047 }
46048 impl CommandBufferInheritanceRenderPassTransformInfoQCOM {
builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a>46049     pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
46050         CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder {
46051             inner: CommandBufferInheritanceRenderPassTransformInfoQCOM::default(),
46052             marker: ::std::marker::PhantomData,
46053         }
46054     }
46055 }
46056 #[repr(transparent)]
46057 pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
46058     inner: CommandBufferInheritanceRenderPassTransformInfoQCOM,
46059     marker: ::std::marker::PhantomData<&'a ()>,
46060 }
46061 unsafe impl ExtendsCommandBufferInheritanceInfo
46062     for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_>
46063 {
46064 }
46065 unsafe impl ExtendsCommandBufferInheritanceInfo
46066     for CommandBufferInheritanceRenderPassTransformInfoQCOM
46067 {
46068 }
46069 impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
46070     type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM;
deref(&self) -> &Self::Target46071     fn deref(&self) -> &Self::Target {
46072         &self.inner
46073     }
46074 }
46075 impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46076     fn deref_mut(&mut self) -> &mut Self::Target {
46077         &mut self.inner
46078     }
46079 }
46080 impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
transform( mut self, transform: SurfaceTransformFlagsKHR, ) -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a>46081     pub fn transform(
46082         mut self,
46083         transform: SurfaceTransformFlagsKHR,
46084     ) -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
46085         self.inner.transform = transform;
46086         self
46087     }
render_area( mut self, render_area: Rect2D, ) -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a>46088     pub fn render_area(
46089         mut self,
46090         render_area: Rect2D,
46091     ) -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
46092         self.inner.render_area = render_area;
46093         self
46094     }
46095     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46096     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46097     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM46098     pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
46099         self.inner
46100     }
46101 }
46102 #[repr(C)]
46103 #[derive(Copy, Clone, Debug)]
46104 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>"]
46105 pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
46106     pub s_type: StructureType,
46107     pub p_next: *mut c_void,
46108     pub diagnostics_config: Bool32,
46109 }
46110 impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV {
default() -> PhysicalDeviceDiagnosticsConfigFeaturesNV46111     fn default() -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
46112         PhysicalDeviceDiagnosticsConfigFeaturesNV {
46113             s_type: StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
46114             p_next: ::std::ptr::null_mut(),
46115             diagnostics_config: Bool32::default(),
46116         }
46117     }
46118 }
46119 impl PhysicalDeviceDiagnosticsConfigFeaturesNV {
builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a>46120     pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
46121         PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder {
46122             inner: PhysicalDeviceDiagnosticsConfigFeaturesNV::default(),
46123             marker: ::std::marker::PhantomData,
46124         }
46125     }
46126 }
46127 #[repr(transparent)]
46128 pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
46129     inner: PhysicalDeviceDiagnosticsConfigFeaturesNV,
46130     marker: ::std::marker::PhantomData<&'a ()>,
46131 }
46132 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {}
46133 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
46134 impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
46135     type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV;
deref(&self) -> &Self::Target46136     fn deref(&self) -> &Self::Target {
46137         &self.inner
46138     }
46139 }
46140 impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46141     fn deref_mut(&mut self) -> &mut Self::Target {
46142         &mut self.inner
46143     }
46144 }
46145 impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
diagnostics_config( mut self, diagnostics_config: bool, ) -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a>46146     pub fn diagnostics_config(
46147         mut self,
46148         diagnostics_config: bool,
46149     ) -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
46150         self.inner.diagnostics_config = diagnostics_config.into();
46151         self
46152     }
46153     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46154     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46155     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV46156     pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
46157         self.inner
46158     }
46159 }
46160 #[repr(C)]
46161 #[derive(Copy, Clone, Debug)]
46162 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>"]
46163 pub struct DeviceDiagnosticsConfigCreateInfoNV {
46164     pub s_type: StructureType,
46165     pub p_next: *const c_void,
46166     pub flags: DeviceDiagnosticsConfigFlagsNV,
46167 }
46168 impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV {
default() -> DeviceDiagnosticsConfigCreateInfoNV46169     fn default() -> DeviceDiagnosticsConfigCreateInfoNV {
46170         DeviceDiagnosticsConfigCreateInfoNV {
46171             s_type: StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
46172             p_next: ::std::ptr::null(),
46173             flags: DeviceDiagnosticsConfigFlagsNV::default(),
46174         }
46175     }
46176 }
46177 impl DeviceDiagnosticsConfigCreateInfoNV {
builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a>46178     pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
46179         DeviceDiagnosticsConfigCreateInfoNVBuilder {
46180             inner: DeviceDiagnosticsConfigCreateInfoNV::default(),
46181             marker: ::std::marker::PhantomData,
46182         }
46183     }
46184 }
46185 #[repr(transparent)]
46186 pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
46187     inner: DeviceDiagnosticsConfigCreateInfoNV,
46188     marker: ::std::marker::PhantomData<&'a ()>,
46189 }
46190 unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {}
46191 unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {}
46192 impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
46193     type Target = DeviceDiagnosticsConfigCreateInfoNV;
deref(&self) -> &Self::Target46194     fn deref(&self) -> &Self::Target {
46195         &self.inner
46196     }
46197 }
46198 impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46199     fn deref_mut(&mut self) -> &mut Self::Target {
46200         &mut self.inner
46201     }
46202 }
46203 impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
flags( mut self, flags: DeviceDiagnosticsConfigFlagsNV, ) -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a>46204     pub fn flags(
46205         mut self,
46206         flags: DeviceDiagnosticsConfigFlagsNV,
46207     ) -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
46208         self.inner.flags = flags;
46209         self
46210     }
46211     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46212     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46213     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> DeviceDiagnosticsConfigCreateInfoNV46214     pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV {
46215         self.inner
46216     }
46217 }
46218 #[repr(C)]
46219 #[derive(Copy, Clone, Debug)]
46220 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.html>"]
46221 pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
46222     pub s_type: StructureType,
46223     pub p_next: *mut c_void,
46224     pub shader_zero_initialize_workgroup_memory: Bool32,
46225 }
46226 impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
default() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR46227     fn default() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
46228         PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
46229             s_type: StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR,
46230             p_next: ::std::ptr::null_mut(),
46231             shader_zero_initialize_workgroup_memory: Bool32::default(),
46232         }
46233     }
46234 }
46235 impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a>46236     pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
46237         PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder {
46238             inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::default(),
46239             marker: ::std::marker::PhantomData,
46240         }
46241     }
46242 }
46243 #[repr(transparent)]
46244 pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
46245     inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR,
46246     marker: ::std::marker::PhantomData<&'a ()>,
46247 }
46248 unsafe impl ExtendsDeviceCreateInfo
46249     for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'_>
46250 {
46251 }
46252 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {}
46253 impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
46254     type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
deref(&self) -> &Self::Target46255     fn deref(&self) -> &Self::Target {
46256         &self.inner
46257     }
46258 }
46259 impl<'a> ::std::ops::DerefMut
46260     for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a>
46261 {
deref_mut(&mut self) -> &mut Self::Target46262     fn deref_mut(&mut self) -> &mut Self::Target {
46263         &mut self.inner
46264     }
46265 }
46266 impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
shader_zero_initialize_workgroup_memory( mut self, shader_zero_initialize_workgroup_memory: bool, ) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a>46267     pub fn shader_zero_initialize_workgroup_memory(
46268         mut self,
46269         shader_zero_initialize_workgroup_memory: bool,
46270     ) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
46271         self.inner.shader_zero_initialize_workgroup_memory =
46272             shader_zero_initialize_workgroup_memory.into();
46273         self
46274     }
46275     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46276     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46277     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR46278     pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
46279         self.inner
46280     }
46281 }
46282 #[repr(C)]
46283 #[derive(Copy, Clone, Debug)]
46284 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html>"]
46285 pub struct PhysicalDeviceRobustness2FeaturesEXT {
46286     pub s_type: StructureType,
46287     pub p_next: *mut c_void,
46288     pub robust_buffer_access2: Bool32,
46289     pub robust_image_access2: Bool32,
46290     pub null_descriptor: Bool32,
46291 }
46292 impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT {
default() -> PhysicalDeviceRobustness2FeaturesEXT46293     fn default() -> PhysicalDeviceRobustness2FeaturesEXT {
46294         PhysicalDeviceRobustness2FeaturesEXT {
46295             s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
46296             p_next: ::std::ptr::null_mut(),
46297             robust_buffer_access2: Bool32::default(),
46298             robust_image_access2: Bool32::default(),
46299             null_descriptor: Bool32::default(),
46300         }
46301     }
46302 }
46303 impl PhysicalDeviceRobustness2FeaturesEXT {
builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a>46304     pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
46305         PhysicalDeviceRobustness2FeaturesEXTBuilder {
46306             inner: PhysicalDeviceRobustness2FeaturesEXT::default(),
46307             marker: ::std::marker::PhantomData,
46308         }
46309     }
46310 }
46311 #[repr(transparent)]
46312 pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
46313     inner: PhysicalDeviceRobustness2FeaturesEXT,
46314     marker: ::std::marker::PhantomData<&'a ()>,
46315 }
46316 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {}
46317 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {}
46318 impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
46319     type Target = PhysicalDeviceRobustness2FeaturesEXT;
deref(&self) -> &Self::Target46320     fn deref(&self) -> &Self::Target {
46321         &self.inner
46322     }
46323 }
46324 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46325     fn deref_mut(&mut self) -> &mut Self::Target {
46326         &mut self.inner
46327     }
46328 }
46329 impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
robust_buffer_access2( mut self, robust_buffer_access2: bool, ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a>46330     pub fn robust_buffer_access2(
46331         mut self,
46332         robust_buffer_access2: bool,
46333     ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
46334         self.inner.robust_buffer_access2 = robust_buffer_access2.into();
46335         self
46336     }
robust_image_access2( mut self, robust_image_access2: bool, ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a>46337     pub fn robust_image_access2(
46338         mut self,
46339         robust_image_access2: bool,
46340     ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
46341         self.inner.robust_image_access2 = robust_image_access2.into();
46342         self
46343     }
null_descriptor( mut self, null_descriptor: bool, ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a>46344     pub fn null_descriptor(
46345         mut self,
46346         null_descriptor: bool,
46347     ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
46348         self.inner.null_descriptor = null_descriptor.into();
46349         self
46350     }
46351     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46352     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46353     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRobustness2FeaturesEXT46354     pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT {
46355         self.inner
46356     }
46357 }
46358 #[repr(C)]
46359 #[derive(Copy, Clone, Debug)]
46360 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html>"]
46361 pub struct PhysicalDeviceRobustness2PropertiesEXT {
46362     pub s_type: StructureType,
46363     pub p_next: *mut c_void,
46364     pub robust_storage_buffer_access_size_alignment: DeviceSize,
46365     pub robust_uniform_buffer_access_size_alignment: DeviceSize,
46366 }
46367 impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT {
default() -> PhysicalDeviceRobustness2PropertiesEXT46368     fn default() -> PhysicalDeviceRobustness2PropertiesEXT {
46369         PhysicalDeviceRobustness2PropertiesEXT {
46370             s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
46371             p_next: ::std::ptr::null_mut(),
46372             robust_storage_buffer_access_size_alignment: DeviceSize::default(),
46373             robust_uniform_buffer_access_size_alignment: DeviceSize::default(),
46374         }
46375     }
46376 }
46377 impl PhysicalDeviceRobustness2PropertiesEXT {
builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a>46378     pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
46379         PhysicalDeviceRobustness2PropertiesEXTBuilder {
46380             inner: PhysicalDeviceRobustness2PropertiesEXT::default(),
46381             marker: ::std::marker::PhantomData,
46382         }
46383     }
46384 }
46385 #[repr(transparent)]
46386 pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
46387     inner: PhysicalDeviceRobustness2PropertiesEXT,
46388     marker: ::std::marker::PhantomData<&'a ()>,
46389 }
46390 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {}
46391 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {}
46392 impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
46393     type Target = PhysicalDeviceRobustness2PropertiesEXT;
deref(&self) -> &Self::Target46394     fn deref(&self) -> &Self::Target {
46395         &self.inner
46396     }
46397 }
46398 impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46399     fn deref_mut(&mut self) -> &mut Self::Target {
46400         &mut self.inner
46401     }
46402 }
46403 impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
robust_storage_buffer_access_size_alignment( mut self, robust_storage_buffer_access_size_alignment: DeviceSize, ) -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a>46404     pub fn robust_storage_buffer_access_size_alignment(
46405         mut self,
46406         robust_storage_buffer_access_size_alignment: DeviceSize,
46407     ) -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
46408         self.inner.robust_storage_buffer_access_size_alignment =
46409             robust_storage_buffer_access_size_alignment;
46410         self
46411     }
robust_uniform_buffer_access_size_alignment( mut self, robust_uniform_buffer_access_size_alignment: DeviceSize, ) -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a>46412     pub fn robust_uniform_buffer_access_size_alignment(
46413         mut self,
46414         robust_uniform_buffer_access_size_alignment: DeviceSize,
46415     ) -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
46416         self.inner.robust_uniform_buffer_access_size_alignment =
46417             robust_uniform_buffer_access_size_alignment;
46418         self
46419     }
46420     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46421     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46422     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceRobustness2PropertiesEXT46423     pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT {
46424         self.inner
46425     }
46426 }
46427 #[repr(C)]
46428 #[derive(Copy, Clone, Debug)]
46429 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageRobustnessFeaturesEXT.html>"]
46430 pub struct PhysicalDeviceImageRobustnessFeaturesEXT {
46431     pub s_type: StructureType,
46432     pub p_next: *mut c_void,
46433     pub robust_image_access: Bool32,
46434 }
46435 impl ::std::default::Default for PhysicalDeviceImageRobustnessFeaturesEXT {
default() -> PhysicalDeviceImageRobustnessFeaturesEXT46436     fn default() -> PhysicalDeviceImageRobustnessFeaturesEXT {
46437         PhysicalDeviceImageRobustnessFeaturesEXT {
46438             s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT,
46439             p_next: ::std::ptr::null_mut(),
46440             robust_image_access: Bool32::default(),
46441         }
46442     }
46443 }
46444 impl PhysicalDeviceImageRobustnessFeaturesEXT {
builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a>46445     pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
46446         PhysicalDeviceImageRobustnessFeaturesEXTBuilder {
46447             inner: PhysicalDeviceImageRobustnessFeaturesEXT::default(),
46448             marker: ::std::marker::PhantomData,
46449         }
46450     }
46451 }
46452 #[repr(transparent)]
46453 pub struct PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
46454     inner: PhysicalDeviceImageRobustnessFeaturesEXT,
46455     marker: ::std::marker::PhantomData<&'a ()>,
46456 }
46457 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'_> {}
46458 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXT {}
46459 impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
46460     type Target = PhysicalDeviceImageRobustnessFeaturesEXT;
deref(&self) -> &Self::Target46461     fn deref(&self) -> &Self::Target {
46462         &self.inner
46463     }
46464 }
46465 impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46466     fn deref_mut(&mut self) -> &mut Self::Target {
46467         &mut self.inner
46468     }
46469 }
46470 impl<'a> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
robust_image_access( mut self, robust_image_access: bool, ) -> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a>46471     pub fn robust_image_access(
46472         mut self,
46473         robust_image_access: bool,
46474     ) -> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
46475         self.inner.robust_image_access = robust_image_access.into();
46476         self
46477     }
46478     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46479     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46480     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceImageRobustnessFeaturesEXT46481     pub fn build(self) -> PhysicalDeviceImageRobustnessFeaturesEXT {
46482         self.inner
46483     }
46484 }
46485 #[repr(C)]
46486 #[derive(Copy, Clone, Debug)]
46487 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html>"]
46488 pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
46489     pub s_type: StructureType,
46490     pub p_next: *mut c_void,
46491     pub workgroup_memory_explicit_layout: Bool32,
46492     pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32,
46493     pub workgroup_memory_explicit_layout8_bit_access: Bool32,
46494     pub workgroup_memory_explicit_layout16_bit_access: Bool32,
46495 }
46496 impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
default() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR46497     fn default() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
46498         PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
46499             s_type: StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
46500             p_next: ::std::ptr::null_mut(),
46501             workgroup_memory_explicit_layout: Bool32::default(),
46502             workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(),
46503             workgroup_memory_explicit_layout8_bit_access: Bool32::default(),
46504             workgroup_memory_explicit_layout16_bit_access: Bool32::default(),
46505         }
46506     }
46507 }
46508 impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>46509     pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
46510         PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder {
46511             inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::default(),
46512             marker: ::std::marker::PhantomData,
46513         }
46514     }
46515 }
46516 #[repr(transparent)]
46517 pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
46518     inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR,
46519     marker: ::std::marker::PhantomData<&'a ()>,
46520 }
46521 unsafe impl ExtendsDeviceCreateInfo
46522     for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_>
46523 {
46524 }
46525 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {}
46526 impl<'a> ::std::ops::Deref for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
46527     type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
deref(&self) -> &Self::Target46528     fn deref(&self) -> &Self::Target {
46529         &self.inner
46530     }
46531 }
46532 impl<'a> ::std::ops::DerefMut
46533     for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>
46534 {
deref_mut(&mut self) -> &mut Self::Target46535     fn deref_mut(&mut self) -> &mut Self::Target {
46536         &mut self.inner
46537     }
46538 }
46539 impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
workgroup_memory_explicit_layout( mut self, workgroup_memory_explicit_layout: bool, ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>46540     pub fn workgroup_memory_explicit_layout(
46541         mut self,
46542         workgroup_memory_explicit_layout: bool,
46543     ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
46544         self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into();
46545         self
46546     }
workgroup_memory_explicit_layout_scalar_block_layout( mut self, workgroup_memory_explicit_layout_scalar_block_layout: bool, ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>46547     pub fn workgroup_memory_explicit_layout_scalar_block_layout(
46548         mut self,
46549         workgroup_memory_explicit_layout_scalar_block_layout: bool,
46550     ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
46551         self.inner
46552             .workgroup_memory_explicit_layout_scalar_block_layout =
46553             workgroup_memory_explicit_layout_scalar_block_layout.into();
46554         self
46555     }
workgroup_memory_explicit_layout8_bit_access( mut self, workgroup_memory_explicit_layout8_bit_access: bool, ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>46556     pub fn workgroup_memory_explicit_layout8_bit_access(
46557         mut self,
46558         workgroup_memory_explicit_layout8_bit_access: bool,
46559     ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
46560         self.inner.workgroup_memory_explicit_layout8_bit_access =
46561             workgroup_memory_explicit_layout8_bit_access.into();
46562         self
46563     }
workgroup_memory_explicit_layout16_bit_access( mut self, workgroup_memory_explicit_layout16_bit_access: bool, ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a>46564     pub fn workgroup_memory_explicit_layout16_bit_access(
46565         mut self,
46566         workgroup_memory_explicit_layout16_bit_access: bool,
46567     ) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
46568         self.inner.workgroup_memory_explicit_layout16_bit_access =
46569             workgroup_memory_explicit_layout16_bit_access.into();
46570         self
46571     }
46572     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46573     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46574     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR46575     pub fn build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
46576         self.inner
46577     }
46578 }
46579 #[repr(C)]
46580 #[derive(Copy, Clone, Debug)]
46581 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html>"]
46582 pub struct PhysicalDevicePortabilitySubsetFeaturesKHR {
46583     pub s_type: StructureType,
46584     pub p_next: *mut c_void,
46585     pub constant_alpha_color_blend_factors: Bool32,
46586     pub events: Bool32,
46587     pub image_view_format_reinterpretation: Bool32,
46588     pub image_view_format_swizzle: Bool32,
46589     pub image_view2_d_on3_d_image: Bool32,
46590     pub multisample_array_image: Bool32,
46591     pub mutable_comparison_samplers: Bool32,
46592     pub point_polygons: Bool32,
46593     pub sampler_mip_lod_bias: Bool32,
46594     pub separate_stencil_mask_ref: Bool32,
46595     pub shader_sample_rate_interpolation_functions: Bool32,
46596     pub tessellation_isolines: Bool32,
46597     pub tessellation_point_mode: Bool32,
46598     pub triangle_fans: Bool32,
46599     pub vertex_attribute_access_beyond_stride: Bool32,
46600 }
46601 impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR {
default() -> PhysicalDevicePortabilitySubsetFeaturesKHR46602     fn default() -> PhysicalDevicePortabilitySubsetFeaturesKHR {
46603         PhysicalDevicePortabilitySubsetFeaturesKHR {
46604             s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
46605             p_next: ::std::ptr::null_mut(),
46606             constant_alpha_color_blend_factors: Bool32::default(),
46607             events: Bool32::default(),
46608             image_view_format_reinterpretation: Bool32::default(),
46609             image_view_format_swizzle: Bool32::default(),
46610             image_view2_d_on3_d_image: Bool32::default(),
46611             multisample_array_image: Bool32::default(),
46612             mutable_comparison_samplers: Bool32::default(),
46613             point_polygons: Bool32::default(),
46614             sampler_mip_lod_bias: Bool32::default(),
46615             separate_stencil_mask_ref: Bool32::default(),
46616             shader_sample_rate_interpolation_functions: Bool32::default(),
46617             tessellation_isolines: Bool32::default(),
46618             tessellation_point_mode: Bool32::default(),
46619             triangle_fans: Bool32::default(),
46620             vertex_attribute_access_beyond_stride: Bool32::default(),
46621         }
46622     }
46623 }
46624 impl PhysicalDevicePortabilitySubsetFeaturesKHR {
builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46625     pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46626         PhysicalDevicePortabilitySubsetFeaturesKHRBuilder {
46627             inner: PhysicalDevicePortabilitySubsetFeaturesKHR::default(),
46628             marker: ::std::marker::PhantomData,
46629         }
46630     }
46631 }
46632 #[repr(transparent)]
46633 pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46634     inner: PhysicalDevicePortabilitySubsetFeaturesKHR,
46635     marker: ::std::marker::PhantomData<&'a ()>,
46636 }
46637 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {}
46638 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {}
46639 impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46640     type Target = PhysicalDevicePortabilitySubsetFeaturesKHR;
deref(&self) -> &Self::Target46641     fn deref(&self) -> &Self::Target {
46642         &self.inner
46643     }
46644 }
46645 impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46646     fn deref_mut(&mut self) -> &mut Self::Target {
46647         &mut self.inner
46648     }
46649 }
46650 impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
constant_alpha_color_blend_factors( mut self, constant_alpha_color_blend_factors: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46651     pub fn constant_alpha_color_blend_factors(
46652         mut self,
46653         constant_alpha_color_blend_factors: bool,
46654     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46655         self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into();
46656         self
46657     }
events(mut self, events: bool) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46658     pub fn events(mut self, events: bool) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46659         self.inner.events = events.into();
46660         self
46661     }
image_view_format_reinterpretation( mut self, image_view_format_reinterpretation: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46662     pub fn image_view_format_reinterpretation(
46663         mut self,
46664         image_view_format_reinterpretation: bool,
46665     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46666         self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into();
46667         self
46668     }
image_view_format_swizzle( mut self, image_view_format_swizzle: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46669     pub fn image_view_format_swizzle(
46670         mut self,
46671         image_view_format_swizzle: bool,
46672     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46673         self.inner.image_view_format_swizzle = image_view_format_swizzle.into();
46674         self
46675     }
image_view2_d_on3_d_image( mut self, image_view2_d_on3_d_image: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46676     pub fn image_view2_d_on3_d_image(
46677         mut self,
46678         image_view2_d_on3_d_image: bool,
46679     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46680         self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into();
46681         self
46682     }
multisample_array_image( mut self, multisample_array_image: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46683     pub fn multisample_array_image(
46684         mut self,
46685         multisample_array_image: bool,
46686     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46687         self.inner.multisample_array_image = multisample_array_image.into();
46688         self
46689     }
mutable_comparison_samplers( mut self, mutable_comparison_samplers: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46690     pub fn mutable_comparison_samplers(
46691         mut self,
46692         mutable_comparison_samplers: bool,
46693     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46694         self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into();
46695         self
46696     }
point_polygons( mut self, point_polygons: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46697     pub fn point_polygons(
46698         mut self,
46699         point_polygons: bool,
46700     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46701         self.inner.point_polygons = point_polygons.into();
46702         self
46703     }
sampler_mip_lod_bias( mut self, sampler_mip_lod_bias: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46704     pub fn sampler_mip_lod_bias(
46705         mut self,
46706         sampler_mip_lod_bias: bool,
46707     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46708         self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into();
46709         self
46710     }
separate_stencil_mask_ref( mut self, separate_stencil_mask_ref: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46711     pub fn separate_stencil_mask_ref(
46712         mut self,
46713         separate_stencil_mask_ref: bool,
46714     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46715         self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into();
46716         self
46717     }
shader_sample_rate_interpolation_functions( mut self, shader_sample_rate_interpolation_functions: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46718     pub fn shader_sample_rate_interpolation_functions(
46719         mut self,
46720         shader_sample_rate_interpolation_functions: bool,
46721     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46722         self.inner.shader_sample_rate_interpolation_functions =
46723             shader_sample_rate_interpolation_functions.into();
46724         self
46725     }
tessellation_isolines( mut self, tessellation_isolines: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46726     pub fn tessellation_isolines(
46727         mut self,
46728         tessellation_isolines: bool,
46729     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46730         self.inner.tessellation_isolines = tessellation_isolines.into();
46731         self
46732     }
tessellation_point_mode( mut self, tessellation_point_mode: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46733     pub fn tessellation_point_mode(
46734         mut self,
46735         tessellation_point_mode: bool,
46736     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46737         self.inner.tessellation_point_mode = tessellation_point_mode.into();
46738         self
46739     }
triangle_fans( mut self, triangle_fans: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46740     pub fn triangle_fans(
46741         mut self,
46742         triangle_fans: bool,
46743     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46744         self.inner.triangle_fans = triangle_fans.into();
46745         self
46746     }
vertex_attribute_access_beyond_stride( mut self, vertex_attribute_access_beyond_stride: bool, ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a>46747     pub fn vertex_attribute_access_beyond_stride(
46748         mut self,
46749         vertex_attribute_access_beyond_stride: bool,
46750     ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
46751         self.inner.vertex_attribute_access_beyond_stride =
46752             vertex_attribute_access_beyond_stride.into();
46753         self
46754     }
46755     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46756     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46757     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR46758     pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR {
46759         self.inner
46760     }
46761 }
46762 #[repr(C)]
46763 #[derive(Copy, Clone, Debug)]
46764 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html>"]
46765 pub struct PhysicalDevicePortabilitySubsetPropertiesKHR {
46766     pub s_type: StructureType,
46767     pub p_next: *mut c_void,
46768     pub min_vertex_input_binding_stride_alignment: u32,
46769 }
46770 impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR {
default() -> PhysicalDevicePortabilitySubsetPropertiesKHR46771     fn default() -> PhysicalDevicePortabilitySubsetPropertiesKHR {
46772         PhysicalDevicePortabilitySubsetPropertiesKHR {
46773             s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
46774             p_next: ::std::ptr::null_mut(),
46775             min_vertex_input_binding_stride_alignment: u32::default(),
46776         }
46777     }
46778 }
46779 impl PhysicalDevicePortabilitySubsetPropertiesKHR {
builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a>46780     pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
46781         PhysicalDevicePortabilitySubsetPropertiesKHRBuilder {
46782             inner: PhysicalDevicePortabilitySubsetPropertiesKHR::default(),
46783             marker: ::std::marker::PhantomData,
46784         }
46785     }
46786 }
46787 #[repr(transparent)]
46788 pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
46789     inner: PhysicalDevicePortabilitySubsetPropertiesKHR,
46790     marker: ::std::marker::PhantomData<&'a ()>,
46791 }
46792 unsafe impl ExtendsPhysicalDeviceProperties2
46793     for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_>
46794 {
46795 }
46796 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {}
46797 impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
46798     type Target = PhysicalDevicePortabilitySubsetPropertiesKHR;
deref(&self) -> &Self::Target46799     fn deref(&self) -> &Self::Target {
46800         &self.inner
46801     }
46802 }
46803 impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46804     fn deref_mut(&mut self) -> &mut Self::Target {
46805         &mut self.inner
46806     }
46807 }
46808 impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
min_vertex_input_binding_stride_alignment( mut self, min_vertex_input_binding_stride_alignment: u32, ) -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a>46809     pub fn min_vertex_input_binding_stride_alignment(
46810         mut self,
46811         min_vertex_input_binding_stride_alignment: u32,
46812     ) -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
46813         self.inner.min_vertex_input_binding_stride_alignment =
46814             min_vertex_input_binding_stride_alignment;
46815         self
46816     }
46817     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46818     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46819     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR46820     pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR {
46821         self.inner
46822     }
46823 }
46824 #[repr(C)]
46825 #[derive(Copy, Clone, Debug)]
46826 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html>"]
46827 pub struct PhysicalDevice4444FormatsFeaturesEXT {
46828     pub s_type: StructureType,
46829     pub p_next: *mut c_void,
46830     pub format_a4r4g4b4: Bool32,
46831     pub format_a4b4g4r4: Bool32,
46832 }
46833 impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT {
default() -> PhysicalDevice4444FormatsFeaturesEXT46834     fn default() -> PhysicalDevice4444FormatsFeaturesEXT {
46835         PhysicalDevice4444FormatsFeaturesEXT {
46836             s_type: StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
46837             p_next: ::std::ptr::null_mut(),
46838             format_a4r4g4b4: Bool32::default(),
46839             format_a4b4g4r4: Bool32::default(),
46840         }
46841     }
46842 }
46843 impl PhysicalDevice4444FormatsFeaturesEXT {
builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a>46844     pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
46845         PhysicalDevice4444FormatsFeaturesEXTBuilder {
46846             inner: PhysicalDevice4444FormatsFeaturesEXT::default(),
46847             marker: ::std::marker::PhantomData,
46848         }
46849     }
46850 }
46851 #[repr(transparent)]
46852 pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
46853     inner: PhysicalDevice4444FormatsFeaturesEXT,
46854     marker: ::std::marker::PhantomData<&'a ()>,
46855 }
46856 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {}
46857 unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {}
46858 impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
46859     type Target = PhysicalDevice4444FormatsFeaturesEXT;
deref(&self) -> &Self::Target46860     fn deref(&self) -> &Self::Target {
46861         &self.inner
46862     }
46863 }
46864 impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46865     fn deref_mut(&mut self) -> &mut Self::Target {
46866         &mut self.inner
46867     }
46868 }
46869 impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
format_a4r4g4b4( mut self, format_a4r4g4b4: bool, ) -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a>46870     pub fn format_a4r4g4b4(
46871         mut self,
46872         format_a4r4g4b4: bool,
46873     ) -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
46874         self.inner.format_a4r4g4b4 = format_a4r4g4b4.into();
46875         self
46876     }
format_a4b4g4r4( mut self, format_a4b4g4r4: bool, ) -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a>46877     pub fn format_a4b4g4r4(
46878         mut self,
46879         format_a4b4g4r4: bool,
46880     ) -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
46881         self.inner.format_a4b4g4r4 = format_a4b4g4r4.into();
46882         self
46883     }
46884     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46885     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46886     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDevice4444FormatsFeaturesEXT46887     pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT {
46888         self.inner
46889     }
46890 }
46891 #[repr(C)]
46892 #[derive(Copy, Clone, Debug)]
46893 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCopy2KHR.html>"]
46894 pub struct BufferCopy2KHR {
46895     pub s_type: StructureType,
46896     pub p_next: *const c_void,
46897     pub src_offset: DeviceSize,
46898     pub dst_offset: DeviceSize,
46899     pub size: DeviceSize,
46900 }
46901 impl ::std::default::Default for BufferCopy2KHR {
default() -> BufferCopy2KHR46902     fn default() -> BufferCopy2KHR {
46903         BufferCopy2KHR {
46904             s_type: StructureType::BUFFER_COPY_2_KHR,
46905             p_next: ::std::ptr::null(),
46906             src_offset: DeviceSize::default(),
46907             dst_offset: DeviceSize::default(),
46908             size: DeviceSize::default(),
46909         }
46910     }
46911 }
46912 impl BufferCopy2KHR {
builder<'a>() -> BufferCopy2KHRBuilder<'a>46913     pub fn builder<'a>() -> BufferCopy2KHRBuilder<'a> {
46914         BufferCopy2KHRBuilder {
46915             inner: BufferCopy2KHR::default(),
46916             marker: ::std::marker::PhantomData,
46917         }
46918     }
46919 }
46920 #[repr(transparent)]
46921 pub struct BufferCopy2KHRBuilder<'a> {
46922     inner: BufferCopy2KHR,
46923     marker: ::std::marker::PhantomData<&'a ()>,
46924 }
46925 pub unsafe trait ExtendsBufferCopy2KHR {}
46926 impl<'a> ::std::ops::Deref for BufferCopy2KHRBuilder<'a> {
46927     type Target = BufferCopy2KHR;
deref(&self) -> &Self::Target46928     fn deref(&self) -> &Self::Target {
46929         &self.inner
46930     }
46931 }
46932 impl<'a> ::std::ops::DerefMut for BufferCopy2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target46933     fn deref_mut(&mut self) -> &mut Self::Target {
46934         &mut self.inner
46935     }
46936 }
46937 impl<'a> BufferCopy2KHRBuilder<'a> {
src_offset(mut self, src_offset: DeviceSize) -> BufferCopy2KHRBuilder<'a>46938     pub fn src_offset(mut self, src_offset: DeviceSize) -> BufferCopy2KHRBuilder<'a> {
46939         self.inner.src_offset = src_offset;
46940         self
46941     }
dst_offset(mut self, dst_offset: DeviceSize) -> BufferCopy2KHRBuilder<'a>46942     pub fn dst_offset(mut self, dst_offset: DeviceSize) -> BufferCopy2KHRBuilder<'a> {
46943         self.inner.dst_offset = dst_offset;
46944         self
46945     }
size(mut self, size: DeviceSize) -> BufferCopy2KHRBuilder<'a>46946     pub fn size(mut self, size: DeviceSize) -> BufferCopy2KHRBuilder<'a> {
46947         self.inner.size = size;
46948         self
46949     }
46950     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
46951     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
46952     #[doc = r" valid extension structs can be pushed into the chain."]
46953     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
46954     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferCopy2KHR>( mut self, next: &'a mut T, ) -> BufferCopy2KHRBuilder<'a>46955     pub fn push_next<T: ExtendsBufferCopy2KHR>(
46956         mut self,
46957         next: &'a mut T,
46958     ) -> BufferCopy2KHRBuilder<'a> {
46959         unsafe {
46960             let next_ptr = next as *mut T as *mut BaseOutStructure;
46961             let last_next = ptr_chain_iter(next).last().unwrap();
46962             (*last_next).p_next = self.inner.p_next as _;
46963             self.inner.p_next = next_ptr as _;
46964         }
46965         self
46966     }
46967     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
46968     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
46969     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferCopy2KHR46970     pub fn build(self) -> BufferCopy2KHR {
46971         self.inner
46972     }
46973 }
46974 #[repr(C)]
46975 #[derive(Copy, Clone, Debug)]
46976 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCopy2KHR.html>"]
46977 pub struct ImageCopy2KHR {
46978     pub s_type: StructureType,
46979     pub p_next: *const c_void,
46980     pub src_subresource: ImageSubresourceLayers,
46981     pub src_offset: Offset3D,
46982     pub dst_subresource: ImageSubresourceLayers,
46983     pub dst_offset: Offset3D,
46984     pub extent: Extent3D,
46985 }
46986 impl ::std::default::Default for ImageCopy2KHR {
default() -> ImageCopy2KHR46987     fn default() -> ImageCopy2KHR {
46988         ImageCopy2KHR {
46989             s_type: StructureType::IMAGE_COPY_2_KHR,
46990             p_next: ::std::ptr::null(),
46991             src_subresource: ImageSubresourceLayers::default(),
46992             src_offset: Offset3D::default(),
46993             dst_subresource: ImageSubresourceLayers::default(),
46994             dst_offset: Offset3D::default(),
46995             extent: Extent3D::default(),
46996         }
46997     }
46998 }
46999 impl ImageCopy2KHR {
builder<'a>() -> ImageCopy2KHRBuilder<'a>47000     pub fn builder<'a>() -> ImageCopy2KHRBuilder<'a> {
47001         ImageCopy2KHRBuilder {
47002             inner: ImageCopy2KHR::default(),
47003             marker: ::std::marker::PhantomData,
47004         }
47005     }
47006 }
47007 #[repr(transparent)]
47008 pub struct ImageCopy2KHRBuilder<'a> {
47009     inner: ImageCopy2KHR,
47010     marker: ::std::marker::PhantomData<&'a ()>,
47011 }
47012 pub unsafe trait ExtendsImageCopy2KHR {}
47013 impl<'a> ::std::ops::Deref for ImageCopy2KHRBuilder<'a> {
47014     type Target = ImageCopy2KHR;
deref(&self) -> &Self::Target47015     fn deref(&self) -> &Self::Target {
47016         &self.inner
47017     }
47018 }
47019 impl<'a> ::std::ops::DerefMut for ImageCopy2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47020     fn deref_mut(&mut self) -> &mut Self::Target {
47021         &mut self.inner
47022     }
47023 }
47024 impl<'a> ImageCopy2KHRBuilder<'a> {
src_subresource( mut self, src_subresource: ImageSubresourceLayers, ) -> ImageCopy2KHRBuilder<'a>47025     pub fn src_subresource(
47026         mut self,
47027         src_subresource: ImageSubresourceLayers,
47028     ) -> ImageCopy2KHRBuilder<'a> {
47029         self.inner.src_subresource = src_subresource;
47030         self
47031     }
src_offset(mut self, src_offset: Offset3D) -> ImageCopy2KHRBuilder<'a>47032     pub fn src_offset(mut self, src_offset: Offset3D) -> ImageCopy2KHRBuilder<'a> {
47033         self.inner.src_offset = src_offset;
47034         self
47035     }
dst_subresource( mut self, dst_subresource: ImageSubresourceLayers, ) -> ImageCopy2KHRBuilder<'a>47036     pub fn dst_subresource(
47037         mut self,
47038         dst_subresource: ImageSubresourceLayers,
47039     ) -> ImageCopy2KHRBuilder<'a> {
47040         self.inner.dst_subresource = dst_subresource;
47041         self
47042     }
dst_offset(mut self, dst_offset: Offset3D) -> ImageCopy2KHRBuilder<'a>47043     pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageCopy2KHRBuilder<'a> {
47044         self.inner.dst_offset = dst_offset;
47045         self
47046     }
extent(mut self, extent: Extent3D) -> ImageCopy2KHRBuilder<'a>47047     pub fn extent(mut self, extent: Extent3D) -> ImageCopy2KHRBuilder<'a> {
47048         self.inner.extent = extent;
47049         self
47050     }
47051     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47052     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47053     #[doc = r" valid extension structs can be pushed into the chain."]
47054     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47055     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageCopy2KHR>( mut self, next: &'a mut T, ) -> ImageCopy2KHRBuilder<'a>47056     pub fn push_next<T: ExtendsImageCopy2KHR>(
47057         mut self,
47058         next: &'a mut T,
47059     ) -> ImageCopy2KHRBuilder<'a> {
47060         unsafe {
47061             let next_ptr = next as *mut T as *mut BaseOutStructure;
47062             let last_next = ptr_chain_iter(next).last().unwrap();
47063             (*last_next).p_next = self.inner.p_next as _;
47064             self.inner.p_next = next_ptr as _;
47065         }
47066         self
47067     }
47068     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47069     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47070     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageCopy2KHR47071     pub fn build(self) -> ImageCopy2KHR {
47072         self.inner
47073     }
47074 }
47075 #[repr(C)]
47076 #[derive(Copy, Clone, Debug)]
47077 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageBlit2KHR.html>"]
47078 pub struct ImageBlit2KHR {
47079     pub s_type: StructureType,
47080     pub p_next: *const c_void,
47081     pub src_subresource: ImageSubresourceLayers,
47082     pub src_offsets: [Offset3D; 2],
47083     pub dst_subresource: ImageSubresourceLayers,
47084     pub dst_offsets: [Offset3D; 2],
47085 }
47086 impl ::std::default::Default for ImageBlit2KHR {
default() -> ImageBlit2KHR47087     fn default() -> ImageBlit2KHR {
47088         ImageBlit2KHR {
47089             s_type: StructureType::IMAGE_BLIT_2_KHR,
47090             p_next: ::std::ptr::null(),
47091             src_subresource: ImageSubresourceLayers::default(),
47092             src_offsets: unsafe { ::std::mem::zeroed() },
47093             dst_subresource: ImageSubresourceLayers::default(),
47094             dst_offsets: unsafe { ::std::mem::zeroed() },
47095         }
47096     }
47097 }
47098 impl ImageBlit2KHR {
builder<'a>() -> ImageBlit2KHRBuilder<'a>47099     pub fn builder<'a>() -> ImageBlit2KHRBuilder<'a> {
47100         ImageBlit2KHRBuilder {
47101             inner: ImageBlit2KHR::default(),
47102             marker: ::std::marker::PhantomData,
47103         }
47104     }
47105 }
47106 #[repr(transparent)]
47107 pub struct ImageBlit2KHRBuilder<'a> {
47108     inner: ImageBlit2KHR,
47109     marker: ::std::marker::PhantomData<&'a ()>,
47110 }
47111 pub unsafe trait ExtendsImageBlit2KHR {}
47112 impl<'a> ::std::ops::Deref for ImageBlit2KHRBuilder<'a> {
47113     type Target = ImageBlit2KHR;
deref(&self) -> &Self::Target47114     fn deref(&self) -> &Self::Target {
47115         &self.inner
47116     }
47117 }
47118 impl<'a> ::std::ops::DerefMut for ImageBlit2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47119     fn deref_mut(&mut self) -> &mut Self::Target {
47120         &mut self.inner
47121     }
47122 }
47123 impl<'a> ImageBlit2KHRBuilder<'a> {
src_subresource( mut self, src_subresource: ImageSubresourceLayers, ) -> ImageBlit2KHRBuilder<'a>47124     pub fn src_subresource(
47125         mut self,
47126         src_subresource: ImageSubresourceLayers,
47127     ) -> ImageBlit2KHRBuilder<'a> {
47128         self.inner.src_subresource = src_subresource;
47129         self
47130     }
src_offsets(mut self, src_offsets: [Offset3D; 2]) -> ImageBlit2KHRBuilder<'a>47131     pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> ImageBlit2KHRBuilder<'a> {
47132         self.inner.src_offsets = src_offsets;
47133         self
47134     }
dst_subresource( mut self, dst_subresource: ImageSubresourceLayers, ) -> ImageBlit2KHRBuilder<'a>47135     pub fn dst_subresource(
47136         mut self,
47137         dst_subresource: ImageSubresourceLayers,
47138     ) -> ImageBlit2KHRBuilder<'a> {
47139         self.inner.dst_subresource = dst_subresource;
47140         self
47141     }
dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> ImageBlit2KHRBuilder<'a>47142     pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> ImageBlit2KHRBuilder<'a> {
47143         self.inner.dst_offsets = dst_offsets;
47144         self
47145     }
47146     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47147     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47148     #[doc = r" valid extension structs can be pushed into the chain."]
47149     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47150     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageBlit2KHR>( mut self, next: &'a mut T, ) -> ImageBlit2KHRBuilder<'a>47151     pub fn push_next<T: ExtendsImageBlit2KHR>(
47152         mut self,
47153         next: &'a mut T,
47154     ) -> ImageBlit2KHRBuilder<'a> {
47155         unsafe {
47156             let next_ptr = next as *mut T as *mut BaseOutStructure;
47157             let last_next = ptr_chain_iter(next).last().unwrap();
47158             (*last_next).p_next = self.inner.p_next as _;
47159             self.inner.p_next = next_ptr as _;
47160         }
47161         self
47162     }
47163     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47164     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47165     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageBlit2KHR47166     pub fn build(self) -> ImageBlit2KHR {
47167         self.inner
47168     }
47169 }
47170 #[repr(C)]
47171 #[derive(Copy, Clone, Debug)]
47172 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferImageCopy2KHR.html>"]
47173 pub struct BufferImageCopy2KHR {
47174     pub s_type: StructureType,
47175     pub p_next: *const c_void,
47176     pub buffer_offset: DeviceSize,
47177     pub buffer_row_length: u32,
47178     pub buffer_image_height: u32,
47179     pub image_subresource: ImageSubresourceLayers,
47180     pub image_offset: Offset3D,
47181     pub image_extent: Extent3D,
47182 }
47183 impl ::std::default::Default for BufferImageCopy2KHR {
default() -> BufferImageCopy2KHR47184     fn default() -> BufferImageCopy2KHR {
47185         BufferImageCopy2KHR {
47186             s_type: StructureType::BUFFER_IMAGE_COPY_2_KHR,
47187             p_next: ::std::ptr::null(),
47188             buffer_offset: DeviceSize::default(),
47189             buffer_row_length: u32::default(),
47190             buffer_image_height: u32::default(),
47191             image_subresource: ImageSubresourceLayers::default(),
47192             image_offset: Offset3D::default(),
47193             image_extent: Extent3D::default(),
47194         }
47195     }
47196 }
47197 impl BufferImageCopy2KHR {
builder<'a>() -> BufferImageCopy2KHRBuilder<'a>47198     pub fn builder<'a>() -> BufferImageCopy2KHRBuilder<'a> {
47199         BufferImageCopy2KHRBuilder {
47200             inner: BufferImageCopy2KHR::default(),
47201             marker: ::std::marker::PhantomData,
47202         }
47203     }
47204 }
47205 #[repr(transparent)]
47206 pub struct BufferImageCopy2KHRBuilder<'a> {
47207     inner: BufferImageCopy2KHR,
47208     marker: ::std::marker::PhantomData<&'a ()>,
47209 }
47210 pub unsafe trait ExtendsBufferImageCopy2KHR {}
47211 impl<'a> ::std::ops::Deref for BufferImageCopy2KHRBuilder<'a> {
47212     type Target = BufferImageCopy2KHR;
deref(&self) -> &Self::Target47213     fn deref(&self) -> &Self::Target {
47214         &self.inner
47215     }
47216 }
47217 impl<'a> ::std::ops::DerefMut for BufferImageCopy2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47218     fn deref_mut(&mut self) -> &mut Self::Target {
47219         &mut self.inner
47220     }
47221 }
47222 impl<'a> BufferImageCopy2KHRBuilder<'a> {
buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopy2KHRBuilder<'a>47223     pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopy2KHRBuilder<'a> {
47224         self.inner.buffer_offset = buffer_offset;
47225         self
47226     }
buffer_row_length(mut self, buffer_row_length: u32) -> BufferImageCopy2KHRBuilder<'a>47227     pub fn buffer_row_length(mut self, buffer_row_length: u32) -> BufferImageCopy2KHRBuilder<'a> {
47228         self.inner.buffer_row_length = buffer_row_length;
47229         self
47230     }
buffer_image_height( mut self, buffer_image_height: u32, ) -> BufferImageCopy2KHRBuilder<'a>47231     pub fn buffer_image_height(
47232         mut self,
47233         buffer_image_height: u32,
47234     ) -> BufferImageCopy2KHRBuilder<'a> {
47235         self.inner.buffer_image_height = buffer_image_height;
47236         self
47237     }
image_subresource( mut self, image_subresource: ImageSubresourceLayers, ) -> BufferImageCopy2KHRBuilder<'a>47238     pub fn image_subresource(
47239         mut self,
47240         image_subresource: ImageSubresourceLayers,
47241     ) -> BufferImageCopy2KHRBuilder<'a> {
47242         self.inner.image_subresource = image_subresource;
47243         self
47244     }
image_offset(mut self, image_offset: Offset3D) -> BufferImageCopy2KHRBuilder<'a>47245     pub fn image_offset(mut self, image_offset: Offset3D) -> BufferImageCopy2KHRBuilder<'a> {
47246         self.inner.image_offset = image_offset;
47247         self
47248     }
image_extent(mut self, image_extent: Extent3D) -> BufferImageCopy2KHRBuilder<'a>47249     pub fn image_extent(mut self, image_extent: Extent3D) -> BufferImageCopy2KHRBuilder<'a> {
47250         self.inner.image_extent = image_extent;
47251         self
47252     }
47253     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47254     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47255     #[doc = r" valid extension structs can be pushed into the chain."]
47256     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47257     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBufferImageCopy2KHR>( mut self, next: &'a mut T, ) -> BufferImageCopy2KHRBuilder<'a>47258     pub fn push_next<T: ExtendsBufferImageCopy2KHR>(
47259         mut self,
47260         next: &'a mut T,
47261     ) -> BufferImageCopy2KHRBuilder<'a> {
47262         unsafe {
47263             let next_ptr = next as *mut T as *mut BaseOutStructure;
47264             let last_next = ptr_chain_iter(next).last().unwrap();
47265             (*last_next).p_next = self.inner.p_next as _;
47266             self.inner.p_next = next_ptr as _;
47267         }
47268         self
47269     }
47270     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47271     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47272     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BufferImageCopy2KHR47273     pub fn build(self) -> BufferImageCopy2KHR {
47274         self.inner
47275     }
47276 }
47277 #[repr(C)]
47278 #[derive(Copy, Clone, Debug)]
47279 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageResolve2KHR.html>"]
47280 pub struct ImageResolve2KHR {
47281     pub s_type: StructureType,
47282     pub p_next: *const c_void,
47283     pub src_subresource: ImageSubresourceLayers,
47284     pub src_offset: Offset3D,
47285     pub dst_subresource: ImageSubresourceLayers,
47286     pub dst_offset: Offset3D,
47287     pub extent: Extent3D,
47288 }
47289 impl ::std::default::Default for ImageResolve2KHR {
default() -> ImageResolve2KHR47290     fn default() -> ImageResolve2KHR {
47291         ImageResolve2KHR {
47292             s_type: StructureType::IMAGE_RESOLVE_2_KHR,
47293             p_next: ::std::ptr::null(),
47294             src_subresource: ImageSubresourceLayers::default(),
47295             src_offset: Offset3D::default(),
47296             dst_subresource: ImageSubresourceLayers::default(),
47297             dst_offset: Offset3D::default(),
47298             extent: Extent3D::default(),
47299         }
47300     }
47301 }
47302 impl ImageResolve2KHR {
builder<'a>() -> ImageResolve2KHRBuilder<'a>47303     pub fn builder<'a>() -> ImageResolve2KHRBuilder<'a> {
47304         ImageResolve2KHRBuilder {
47305             inner: ImageResolve2KHR::default(),
47306             marker: ::std::marker::PhantomData,
47307         }
47308     }
47309 }
47310 #[repr(transparent)]
47311 pub struct ImageResolve2KHRBuilder<'a> {
47312     inner: ImageResolve2KHR,
47313     marker: ::std::marker::PhantomData<&'a ()>,
47314 }
47315 pub unsafe trait ExtendsImageResolve2KHR {}
47316 impl<'a> ::std::ops::Deref for ImageResolve2KHRBuilder<'a> {
47317     type Target = ImageResolve2KHR;
deref(&self) -> &Self::Target47318     fn deref(&self) -> &Self::Target {
47319         &self.inner
47320     }
47321 }
47322 impl<'a> ::std::ops::DerefMut for ImageResolve2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47323     fn deref_mut(&mut self) -> &mut Self::Target {
47324         &mut self.inner
47325     }
47326 }
47327 impl<'a> ImageResolve2KHRBuilder<'a> {
src_subresource( mut self, src_subresource: ImageSubresourceLayers, ) -> ImageResolve2KHRBuilder<'a>47328     pub fn src_subresource(
47329         mut self,
47330         src_subresource: ImageSubresourceLayers,
47331     ) -> ImageResolve2KHRBuilder<'a> {
47332         self.inner.src_subresource = src_subresource;
47333         self
47334     }
src_offset(mut self, src_offset: Offset3D) -> ImageResolve2KHRBuilder<'a>47335     pub fn src_offset(mut self, src_offset: Offset3D) -> ImageResolve2KHRBuilder<'a> {
47336         self.inner.src_offset = src_offset;
47337         self
47338     }
dst_subresource( mut self, dst_subresource: ImageSubresourceLayers, ) -> ImageResolve2KHRBuilder<'a>47339     pub fn dst_subresource(
47340         mut self,
47341         dst_subresource: ImageSubresourceLayers,
47342     ) -> ImageResolve2KHRBuilder<'a> {
47343         self.inner.dst_subresource = dst_subresource;
47344         self
47345     }
dst_offset(mut self, dst_offset: Offset3D) -> ImageResolve2KHRBuilder<'a>47346     pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageResolve2KHRBuilder<'a> {
47347         self.inner.dst_offset = dst_offset;
47348         self
47349     }
extent(mut self, extent: Extent3D) -> ImageResolve2KHRBuilder<'a>47350     pub fn extent(mut self, extent: Extent3D) -> ImageResolve2KHRBuilder<'a> {
47351         self.inner.extent = extent;
47352         self
47353     }
47354     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47355     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47356     #[doc = r" valid extension structs can be pushed into the chain."]
47357     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47358     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsImageResolve2KHR>( mut self, next: &'a mut T, ) -> ImageResolve2KHRBuilder<'a>47359     pub fn push_next<T: ExtendsImageResolve2KHR>(
47360         mut self,
47361         next: &'a mut T,
47362     ) -> ImageResolve2KHRBuilder<'a> {
47363         unsafe {
47364             let next_ptr = next as *mut T as *mut BaseOutStructure;
47365             let last_next = ptr_chain_iter(next).last().unwrap();
47366             (*last_next).p_next = self.inner.p_next as _;
47367             self.inner.p_next = next_ptr as _;
47368         }
47369         self
47370     }
47371     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47372     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47373     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ImageResolve2KHR47374     pub fn build(self) -> ImageResolve2KHR {
47375         self.inner
47376     }
47377 }
47378 #[repr(C)]
47379 #[derive(Copy, Clone, Debug)]
47380 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyBufferInfo2KHR.html>"]
47381 pub struct CopyBufferInfo2KHR {
47382     pub s_type: StructureType,
47383     pub p_next: *const c_void,
47384     pub src_buffer: Buffer,
47385     pub dst_buffer: Buffer,
47386     pub region_count: u32,
47387     pub p_regions: *const BufferCopy2KHR,
47388 }
47389 impl ::std::default::Default for CopyBufferInfo2KHR {
default() -> CopyBufferInfo2KHR47390     fn default() -> CopyBufferInfo2KHR {
47391         CopyBufferInfo2KHR {
47392             s_type: StructureType::COPY_BUFFER_INFO_2_KHR,
47393             p_next: ::std::ptr::null(),
47394             src_buffer: Buffer::default(),
47395             dst_buffer: Buffer::default(),
47396             region_count: u32::default(),
47397             p_regions: ::std::ptr::null(),
47398         }
47399     }
47400 }
47401 impl CopyBufferInfo2KHR {
builder<'a>() -> CopyBufferInfo2KHRBuilder<'a>47402     pub fn builder<'a>() -> CopyBufferInfo2KHRBuilder<'a> {
47403         CopyBufferInfo2KHRBuilder {
47404             inner: CopyBufferInfo2KHR::default(),
47405             marker: ::std::marker::PhantomData,
47406         }
47407     }
47408 }
47409 #[repr(transparent)]
47410 pub struct CopyBufferInfo2KHRBuilder<'a> {
47411     inner: CopyBufferInfo2KHR,
47412     marker: ::std::marker::PhantomData<&'a ()>,
47413 }
47414 pub unsafe trait ExtendsCopyBufferInfo2KHR {}
47415 impl<'a> ::std::ops::Deref for CopyBufferInfo2KHRBuilder<'a> {
47416     type Target = CopyBufferInfo2KHR;
deref(&self) -> &Self::Target47417     fn deref(&self) -> &Self::Target {
47418         &self.inner
47419     }
47420 }
47421 impl<'a> ::std::ops::DerefMut for CopyBufferInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47422     fn deref_mut(&mut self) -> &mut Self::Target {
47423         &mut self.inner
47424     }
47425 }
47426 impl<'a> CopyBufferInfo2KHRBuilder<'a> {
src_buffer(mut self, src_buffer: Buffer) -> CopyBufferInfo2KHRBuilder<'a>47427     pub fn src_buffer(mut self, src_buffer: Buffer) -> CopyBufferInfo2KHRBuilder<'a> {
47428         self.inner.src_buffer = src_buffer;
47429         self
47430     }
dst_buffer(mut self, dst_buffer: Buffer) -> CopyBufferInfo2KHRBuilder<'a>47431     pub fn dst_buffer(mut self, dst_buffer: Buffer) -> CopyBufferInfo2KHRBuilder<'a> {
47432         self.inner.dst_buffer = dst_buffer;
47433         self
47434     }
regions(mut self, regions: &'a [BufferCopy2KHR]) -> CopyBufferInfo2KHRBuilder<'a>47435     pub fn regions(mut self, regions: &'a [BufferCopy2KHR]) -> CopyBufferInfo2KHRBuilder<'a> {
47436         self.inner.region_count = regions.len() as _;
47437         self.inner.p_regions = regions.as_ptr();
47438         self
47439     }
47440     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47441     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47442     #[doc = r" valid extension structs can be pushed into the chain."]
47443     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47444     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyBufferInfo2KHR>( mut self, next: &'a mut T, ) -> CopyBufferInfo2KHRBuilder<'a>47445     pub fn push_next<T: ExtendsCopyBufferInfo2KHR>(
47446         mut self,
47447         next: &'a mut T,
47448     ) -> CopyBufferInfo2KHRBuilder<'a> {
47449         unsafe {
47450             let next_ptr = next as *mut T as *mut BaseOutStructure;
47451             let last_next = ptr_chain_iter(next).last().unwrap();
47452             (*last_next).p_next = self.inner.p_next as _;
47453             self.inner.p_next = next_ptr as _;
47454         }
47455         self
47456     }
47457     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47458     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47459     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyBufferInfo2KHR47460     pub fn build(self) -> CopyBufferInfo2KHR {
47461         self.inner
47462     }
47463 }
47464 #[repr(C)]
47465 #[derive(Copy, Clone, Debug)]
47466 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyImageInfo2KHR.html>"]
47467 pub struct CopyImageInfo2KHR {
47468     pub s_type: StructureType,
47469     pub p_next: *const c_void,
47470     pub src_image: Image,
47471     pub src_image_layout: ImageLayout,
47472     pub dst_image: Image,
47473     pub dst_image_layout: ImageLayout,
47474     pub region_count: u32,
47475     pub p_regions: *const ImageCopy2KHR,
47476 }
47477 impl ::std::default::Default for CopyImageInfo2KHR {
default() -> CopyImageInfo2KHR47478     fn default() -> CopyImageInfo2KHR {
47479         CopyImageInfo2KHR {
47480             s_type: StructureType::COPY_IMAGE_INFO_2_KHR,
47481             p_next: ::std::ptr::null(),
47482             src_image: Image::default(),
47483             src_image_layout: ImageLayout::default(),
47484             dst_image: Image::default(),
47485             dst_image_layout: ImageLayout::default(),
47486             region_count: u32::default(),
47487             p_regions: ::std::ptr::null(),
47488         }
47489     }
47490 }
47491 impl CopyImageInfo2KHR {
builder<'a>() -> CopyImageInfo2KHRBuilder<'a>47492     pub fn builder<'a>() -> CopyImageInfo2KHRBuilder<'a> {
47493         CopyImageInfo2KHRBuilder {
47494             inner: CopyImageInfo2KHR::default(),
47495             marker: ::std::marker::PhantomData,
47496         }
47497     }
47498 }
47499 #[repr(transparent)]
47500 pub struct CopyImageInfo2KHRBuilder<'a> {
47501     inner: CopyImageInfo2KHR,
47502     marker: ::std::marker::PhantomData<&'a ()>,
47503 }
47504 pub unsafe trait ExtendsCopyImageInfo2KHR {}
47505 impl<'a> ::std::ops::Deref for CopyImageInfo2KHRBuilder<'a> {
47506     type Target = CopyImageInfo2KHR;
deref(&self) -> &Self::Target47507     fn deref(&self) -> &Self::Target {
47508         &self.inner
47509     }
47510 }
47511 impl<'a> ::std::ops::DerefMut for CopyImageInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47512     fn deref_mut(&mut self) -> &mut Self::Target {
47513         &mut self.inner
47514     }
47515 }
47516 impl<'a> CopyImageInfo2KHRBuilder<'a> {
src_image(mut self, src_image: Image) -> CopyImageInfo2KHRBuilder<'a>47517     pub fn src_image(mut self, src_image: Image) -> CopyImageInfo2KHRBuilder<'a> {
47518         self.inner.src_image = src_image;
47519         self
47520     }
src_image_layout( mut self, src_image_layout: ImageLayout, ) -> CopyImageInfo2KHRBuilder<'a>47521     pub fn src_image_layout(
47522         mut self,
47523         src_image_layout: ImageLayout,
47524     ) -> CopyImageInfo2KHRBuilder<'a> {
47525         self.inner.src_image_layout = src_image_layout;
47526         self
47527     }
dst_image(mut self, dst_image: Image) -> CopyImageInfo2KHRBuilder<'a>47528     pub fn dst_image(mut self, dst_image: Image) -> CopyImageInfo2KHRBuilder<'a> {
47529         self.inner.dst_image = dst_image;
47530         self
47531     }
dst_image_layout( mut self, dst_image_layout: ImageLayout, ) -> CopyImageInfo2KHRBuilder<'a>47532     pub fn dst_image_layout(
47533         mut self,
47534         dst_image_layout: ImageLayout,
47535     ) -> CopyImageInfo2KHRBuilder<'a> {
47536         self.inner.dst_image_layout = dst_image_layout;
47537         self
47538     }
regions(mut self, regions: &'a [ImageCopy2KHR]) -> CopyImageInfo2KHRBuilder<'a>47539     pub fn regions(mut self, regions: &'a [ImageCopy2KHR]) -> CopyImageInfo2KHRBuilder<'a> {
47540         self.inner.region_count = regions.len() as _;
47541         self.inner.p_regions = regions.as_ptr();
47542         self
47543     }
47544     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47545     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47546     #[doc = r" valid extension structs can be pushed into the chain."]
47547     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47548     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyImageInfo2KHR>( mut self, next: &'a mut T, ) -> CopyImageInfo2KHRBuilder<'a>47549     pub fn push_next<T: ExtendsCopyImageInfo2KHR>(
47550         mut self,
47551         next: &'a mut T,
47552     ) -> CopyImageInfo2KHRBuilder<'a> {
47553         unsafe {
47554             let next_ptr = next as *mut T as *mut BaseOutStructure;
47555             let last_next = ptr_chain_iter(next).last().unwrap();
47556             (*last_next).p_next = self.inner.p_next as _;
47557             self.inner.p_next = next_ptr as _;
47558         }
47559         self
47560     }
47561     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47562     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47563     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyImageInfo2KHR47564     pub fn build(self) -> CopyImageInfo2KHR {
47565         self.inner
47566     }
47567 }
47568 #[repr(C)]
47569 #[derive(Copy, Clone, Debug)]
47570 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBlitImageInfo2KHR.html>"]
47571 pub struct BlitImageInfo2KHR {
47572     pub s_type: StructureType,
47573     pub p_next: *const c_void,
47574     pub src_image: Image,
47575     pub src_image_layout: ImageLayout,
47576     pub dst_image: Image,
47577     pub dst_image_layout: ImageLayout,
47578     pub region_count: u32,
47579     pub p_regions: *const ImageBlit2KHR,
47580     pub filter: Filter,
47581 }
47582 impl ::std::default::Default for BlitImageInfo2KHR {
default() -> BlitImageInfo2KHR47583     fn default() -> BlitImageInfo2KHR {
47584         BlitImageInfo2KHR {
47585             s_type: StructureType::BLIT_IMAGE_INFO_2_KHR,
47586             p_next: ::std::ptr::null(),
47587             src_image: Image::default(),
47588             src_image_layout: ImageLayout::default(),
47589             dst_image: Image::default(),
47590             dst_image_layout: ImageLayout::default(),
47591             region_count: u32::default(),
47592             p_regions: ::std::ptr::null(),
47593             filter: Filter::default(),
47594         }
47595     }
47596 }
47597 impl BlitImageInfo2KHR {
builder<'a>() -> BlitImageInfo2KHRBuilder<'a>47598     pub fn builder<'a>() -> BlitImageInfo2KHRBuilder<'a> {
47599         BlitImageInfo2KHRBuilder {
47600             inner: BlitImageInfo2KHR::default(),
47601             marker: ::std::marker::PhantomData,
47602         }
47603     }
47604 }
47605 #[repr(transparent)]
47606 pub struct BlitImageInfo2KHRBuilder<'a> {
47607     inner: BlitImageInfo2KHR,
47608     marker: ::std::marker::PhantomData<&'a ()>,
47609 }
47610 pub unsafe trait ExtendsBlitImageInfo2KHR {}
47611 impl<'a> ::std::ops::Deref for BlitImageInfo2KHRBuilder<'a> {
47612     type Target = BlitImageInfo2KHR;
deref(&self) -> &Self::Target47613     fn deref(&self) -> &Self::Target {
47614         &self.inner
47615     }
47616 }
47617 impl<'a> ::std::ops::DerefMut for BlitImageInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47618     fn deref_mut(&mut self) -> &mut Self::Target {
47619         &mut self.inner
47620     }
47621 }
47622 impl<'a> BlitImageInfo2KHRBuilder<'a> {
src_image(mut self, src_image: Image) -> BlitImageInfo2KHRBuilder<'a>47623     pub fn src_image(mut self, src_image: Image) -> BlitImageInfo2KHRBuilder<'a> {
47624         self.inner.src_image = src_image;
47625         self
47626     }
src_image_layout( mut self, src_image_layout: ImageLayout, ) -> BlitImageInfo2KHRBuilder<'a>47627     pub fn src_image_layout(
47628         mut self,
47629         src_image_layout: ImageLayout,
47630     ) -> BlitImageInfo2KHRBuilder<'a> {
47631         self.inner.src_image_layout = src_image_layout;
47632         self
47633     }
dst_image(mut self, dst_image: Image) -> BlitImageInfo2KHRBuilder<'a>47634     pub fn dst_image(mut self, dst_image: Image) -> BlitImageInfo2KHRBuilder<'a> {
47635         self.inner.dst_image = dst_image;
47636         self
47637     }
dst_image_layout( mut self, dst_image_layout: ImageLayout, ) -> BlitImageInfo2KHRBuilder<'a>47638     pub fn dst_image_layout(
47639         mut self,
47640         dst_image_layout: ImageLayout,
47641     ) -> BlitImageInfo2KHRBuilder<'a> {
47642         self.inner.dst_image_layout = dst_image_layout;
47643         self
47644     }
regions(mut self, regions: &'a [ImageBlit2KHR]) -> BlitImageInfo2KHRBuilder<'a>47645     pub fn regions(mut self, regions: &'a [ImageBlit2KHR]) -> BlitImageInfo2KHRBuilder<'a> {
47646         self.inner.region_count = regions.len() as _;
47647         self.inner.p_regions = regions.as_ptr();
47648         self
47649     }
filter(mut self, filter: Filter) -> BlitImageInfo2KHRBuilder<'a>47650     pub fn filter(mut self, filter: Filter) -> BlitImageInfo2KHRBuilder<'a> {
47651         self.inner.filter = filter;
47652         self
47653     }
47654     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47655     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47656     #[doc = r" valid extension structs can be pushed into the chain."]
47657     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47658     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsBlitImageInfo2KHR>( mut self, next: &'a mut T, ) -> BlitImageInfo2KHRBuilder<'a>47659     pub fn push_next<T: ExtendsBlitImageInfo2KHR>(
47660         mut self,
47661         next: &'a mut T,
47662     ) -> BlitImageInfo2KHRBuilder<'a> {
47663         unsafe {
47664             let next_ptr = next as *mut T as *mut BaseOutStructure;
47665             let last_next = ptr_chain_iter(next).last().unwrap();
47666             (*last_next).p_next = self.inner.p_next as _;
47667             self.inner.p_next = next_ptr as _;
47668         }
47669         self
47670     }
47671     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47672     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47673     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> BlitImageInfo2KHR47674     pub fn build(self) -> BlitImageInfo2KHR {
47675         self.inner
47676     }
47677 }
47678 #[repr(C)]
47679 #[derive(Copy, Clone, Debug)]
47680 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyBufferToImageInfo2KHR.html>"]
47681 pub struct CopyBufferToImageInfo2KHR {
47682     pub s_type: StructureType,
47683     pub p_next: *const c_void,
47684     pub src_buffer: Buffer,
47685     pub dst_image: Image,
47686     pub dst_image_layout: ImageLayout,
47687     pub region_count: u32,
47688     pub p_regions: *const BufferImageCopy2KHR,
47689 }
47690 impl ::std::default::Default for CopyBufferToImageInfo2KHR {
default() -> CopyBufferToImageInfo2KHR47691     fn default() -> CopyBufferToImageInfo2KHR {
47692         CopyBufferToImageInfo2KHR {
47693             s_type: StructureType::COPY_BUFFER_TO_IMAGE_INFO_2_KHR,
47694             p_next: ::std::ptr::null(),
47695             src_buffer: Buffer::default(),
47696             dst_image: Image::default(),
47697             dst_image_layout: ImageLayout::default(),
47698             region_count: u32::default(),
47699             p_regions: ::std::ptr::null(),
47700         }
47701     }
47702 }
47703 impl CopyBufferToImageInfo2KHR {
builder<'a>() -> CopyBufferToImageInfo2KHRBuilder<'a>47704     pub fn builder<'a>() -> CopyBufferToImageInfo2KHRBuilder<'a> {
47705         CopyBufferToImageInfo2KHRBuilder {
47706             inner: CopyBufferToImageInfo2KHR::default(),
47707             marker: ::std::marker::PhantomData,
47708         }
47709     }
47710 }
47711 #[repr(transparent)]
47712 pub struct CopyBufferToImageInfo2KHRBuilder<'a> {
47713     inner: CopyBufferToImageInfo2KHR,
47714     marker: ::std::marker::PhantomData<&'a ()>,
47715 }
47716 pub unsafe trait ExtendsCopyBufferToImageInfo2KHR {}
47717 impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2KHRBuilder<'a> {
47718     type Target = CopyBufferToImageInfo2KHR;
deref(&self) -> &Self::Target47719     fn deref(&self) -> &Self::Target {
47720         &self.inner
47721     }
47722 }
47723 impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47724     fn deref_mut(&mut self) -> &mut Self::Target {
47725         &mut self.inner
47726     }
47727 }
47728 impl<'a> CopyBufferToImageInfo2KHRBuilder<'a> {
src_buffer(mut self, src_buffer: Buffer) -> CopyBufferToImageInfo2KHRBuilder<'a>47729     pub fn src_buffer(mut self, src_buffer: Buffer) -> CopyBufferToImageInfo2KHRBuilder<'a> {
47730         self.inner.src_buffer = src_buffer;
47731         self
47732     }
dst_image(mut self, dst_image: Image) -> CopyBufferToImageInfo2KHRBuilder<'a>47733     pub fn dst_image(mut self, dst_image: Image) -> CopyBufferToImageInfo2KHRBuilder<'a> {
47734         self.inner.dst_image = dst_image;
47735         self
47736     }
dst_image_layout( mut self, dst_image_layout: ImageLayout, ) -> CopyBufferToImageInfo2KHRBuilder<'a>47737     pub fn dst_image_layout(
47738         mut self,
47739         dst_image_layout: ImageLayout,
47740     ) -> CopyBufferToImageInfo2KHRBuilder<'a> {
47741         self.inner.dst_image_layout = dst_image_layout;
47742         self
47743     }
regions( mut self, regions: &'a [BufferImageCopy2KHR], ) -> CopyBufferToImageInfo2KHRBuilder<'a>47744     pub fn regions(
47745         mut self,
47746         regions: &'a [BufferImageCopy2KHR],
47747     ) -> CopyBufferToImageInfo2KHRBuilder<'a> {
47748         self.inner.region_count = regions.len() as _;
47749         self.inner.p_regions = regions.as_ptr();
47750         self
47751     }
47752     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47753     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47754     #[doc = r" valid extension structs can be pushed into the chain."]
47755     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47756     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyBufferToImageInfo2KHR>( mut self, next: &'a mut T, ) -> CopyBufferToImageInfo2KHRBuilder<'a>47757     pub fn push_next<T: ExtendsCopyBufferToImageInfo2KHR>(
47758         mut self,
47759         next: &'a mut T,
47760     ) -> CopyBufferToImageInfo2KHRBuilder<'a> {
47761         unsafe {
47762             let next_ptr = next as *mut T as *mut BaseOutStructure;
47763             let last_next = ptr_chain_iter(next).last().unwrap();
47764             (*last_next).p_next = self.inner.p_next as _;
47765             self.inner.p_next = next_ptr as _;
47766         }
47767         self
47768     }
47769     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47770     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47771     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyBufferToImageInfo2KHR47772     pub fn build(self) -> CopyBufferToImageInfo2KHR {
47773         self.inner
47774     }
47775 }
47776 #[repr(C)]
47777 #[derive(Copy, Clone, Debug)]
47778 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyImageToBufferInfo2KHR.html>"]
47779 pub struct CopyImageToBufferInfo2KHR {
47780     pub s_type: StructureType,
47781     pub p_next: *const c_void,
47782     pub src_image: Image,
47783     pub src_image_layout: ImageLayout,
47784     pub dst_buffer: Buffer,
47785     pub region_count: u32,
47786     pub p_regions: *const BufferImageCopy2KHR,
47787 }
47788 impl ::std::default::Default for CopyImageToBufferInfo2KHR {
default() -> CopyImageToBufferInfo2KHR47789     fn default() -> CopyImageToBufferInfo2KHR {
47790         CopyImageToBufferInfo2KHR {
47791             s_type: StructureType::COPY_IMAGE_TO_BUFFER_INFO_2_KHR,
47792             p_next: ::std::ptr::null(),
47793             src_image: Image::default(),
47794             src_image_layout: ImageLayout::default(),
47795             dst_buffer: Buffer::default(),
47796             region_count: u32::default(),
47797             p_regions: ::std::ptr::null(),
47798         }
47799     }
47800 }
47801 impl CopyImageToBufferInfo2KHR {
builder<'a>() -> CopyImageToBufferInfo2KHRBuilder<'a>47802     pub fn builder<'a>() -> CopyImageToBufferInfo2KHRBuilder<'a> {
47803         CopyImageToBufferInfo2KHRBuilder {
47804             inner: CopyImageToBufferInfo2KHR::default(),
47805             marker: ::std::marker::PhantomData,
47806         }
47807     }
47808 }
47809 #[repr(transparent)]
47810 pub struct CopyImageToBufferInfo2KHRBuilder<'a> {
47811     inner: CopyImageToBufferInfo2KHR,
47812     marker: ::std::marker::PhantomData<&'a ()>,
47813 }
47814 pub unsafe trait ExtendsCopyImageToBufferInfo2KHR {}
47815 impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2KHRBuilder<'a> {
47816     type Target = CopyImageToBufferInfo2KHR;
deref(&self) -> &Self::Target47817     fn deref(&self) -> &Self::Target {
47818         &self.inner
47819     }
47820 }
47821 impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47822     fn deref_mut(&mut self) -> &mut Self::Target {
47823         &mut self.inner
47824     }
47825 }
47826 impl<'a> CopyImageToBufferInfo2KHRBuilder<'a> {
src_image(mut self, src_image: Image) -> CopyImageToBufferInfo2KHRBuilder<'a>47827     pub fn src_image(mut self, src_image: Image) -> CopyImageToBufferInfo2KHRBuilder<'a> {
47828         self.inner.src_image = src_image;
47829         self
47830     }
src_image_layout( mut self, src_image_layout: ImageLayout, ) -> CopyImageToBufferInfo2KHRBuilder<'a>47831     pub fn src_image_layout(
47832         mut self,
47833         src_image_layout: ImageLayout,
47834     ) -> CopyImageToBufferInfo2KHRBuilder<'a> {
47835         self.inner.src_image_layout = src_image_layout;
47836         self
47837     }
dst_buffer(mut self, dst_buffer: Buffer) -> CopyImageToBufferInfo2KHRBuilder<'a>47838     pub fn dst_buffer(mut self, dst_buffer: Buffer) -> CopyImageToBufferInfo2KHRBuilder<'a> {
47839         self.inner.dst_buffer = dst_buffer;
47840         self
47841     }
regions( mut self, regions: &'a [BufferImageCopy2KHR], ) -> CopyImageToBufferInfo2KHRBuilder<'a>47842     pub fn regions(
47843         mut self,
47844         regions: &'a [BufferImageCopy2KHR],
47845     ) -> CopyImageToBufferInfo2KHRBuilder<'a> {
47846         self.inner.region_count = regions.len() as _;
47847         self.inner.p_regions = regions.as_ptr();
47848         self
47849     }
47850     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47851     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47852     #[doc = r" valid extension structs can be pushed into the chain."]
47853     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47854     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsCopyImageToBufferInfo2KHR>( mut self, next: &'a mut T, ) -> CopyImageToBufferInfo2KHRBuilder<'a>47855     pub fn push_next<T: ExtendsCopyImageToBufferInfo2KHR>(
47856         mut self,
47857         next: &'a mut T,
47858     ) -> CopyImageToBufferInfo2KHRBuilder<'a> {
47859         unsafe {
47860             let next_ptr = next as *mut T as *mut BaseOutStructure;
47861             let last_next = ptr_chain_iter(next).last().unwrap();
47862             (*last_next).p_next = self.inner.p_next as _;
47863             self.inner.p_next = next_ptr as _;
47864         }
47865         self
47866     }
47867     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47868     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47869     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> CopyImageToBufferInfo2KHR47870     pub fn build(self) -> CopyImageToBufferInfo2KHR {
47871         self.inner
47872     }
47873 }
47874 #[repr(C)]
47875 #[derive(Copy, Clone, Debug)]
47876 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveImageInfo2KHR.html>"]
47877 pub struct ResolveImageInfo2KHR {
47878     pub s_type: StructureType,
47879     pub p_next: *const c_void,
47880     pub src_image: Image,
47881     pub src_image_layout: ImageLayout,
47882     pub dst_image: Image,
47883     pub dst_image_layout: ImageLayout,
47884     pub region_count: u32,
47885     pub p_regions: *const ImageResolve2KHR,
47886 }
47887 impl ::std::default::Default for ResolveImageInfo2KHR {
default() -> ResolveImageInfo2KHR47888     fn default() -> ResolveImageInfo2KHR {
47889         ResolveImageInfo2KHR {
47890             s_type: StructureType::RESOLVE_IMAGE_INFO_2_KHR,
47891             p_next: ::std::ptr::null(),
47892             src_image: Image::default(),
47893             src_image_layout: ImageLayout::default(),
47894             dst_image: Image::default(),
47895             dst_image_layout: ImageLayout::default(),
47896             region_count: u32::default(),
47897             p_regions: ::std::ptr::null(),
47898         }
47899     }
47900 }
47901 impl ResolveImageInfo2KHR {
builder<'a>() -> ResolveImageInfo2KHRBuilder<'a>47902     pub fn builder<'a>() -> ResolveImageInfo2KHRBuilder<'a> {
47903         ResolveImageInfo2KHRBuilder {
47904             inner: ResolveImageInfo2KHR::default(),
47905             marker: ::std::marker::PhantomData,
47906         }
47907     }
47908 }
47909 #[repr(transparent)]
47910 pub struct ResolveImageInfo2KHRBuilder<'a> {
47911     inner: ResolveImageInfo2KHR,
47912     marker: ::std::marker::PhantomData<&'a ()>,
47913 }
47914 pub unsafe trait ExtendsResolveImageInfo2KHR {}
47915 impl<'a> ::std::ops::Deref for ResolveImageInfo2KHRBuilder<'a> {
47916     type Target = ResolveImageInfo2KHR;
deref(&self) -> &Self::Target47917     fn deref(&self) -> &Self::Target {
47918         &self.inner
47919     }
47920 }
47921 impl<'a> ::std::ops::DerefMut for ResolveImageInfo2KHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target47922     fn deref_mut(&mut self) -> &mut Self::Target {
47923         &mut self.inner
47924     }
47925 }
47926 impl<'a> ResolveImageInfo2KHRBuilder<'a> {
src_image(mut self, src_image: Image) -> ResolveImageInfo2KHRBuilder<'a>47927     pub fn src_image(mut self, src_image: Image) -> ResolveImageInfo2KHRBuilder<'a> {
47928         self.inner.src_image = src_image;
47929         self
47930     }
src_image_layout( mut self, src_image_layout: ImageLayout, ) -> ResolveImageInfo2KHRBuilder<'a>47931     pub fn src_image_layout(
47932         mut self,
47933         src_image_layout: ImageLayout,
47934     ) -> ResolveImageInfo2KHRBuilder<'a> {
47935         self.inner.src_image_layout = src_image_layout;
47936         self
47937     }
dst_image(mut self, dst_image: Image) -> ResolveImageInfo2KHRBuilder<'a>47938     pub fn dst_image(mut self, dst_image: Image) -> ResolveImageInfo2KHRBuilder<'a> {
47939         self.inner.dst_image = dst_image;
47940         self
47941     }
dst_image_layout( mut self, dst_image_layout: ImageLayout, ) -> ResolveImageInfo2KHRBuilder<'a>47942     pub fn dst_image_layout(
47943         mut self,
47944         dst_image_layout: ImageLayout,
47945     ) -> ResolveImageInfo2KHRBuilder<'a> {
47946         self.inner.dst_image_layout = dst_image_layout;
47947         self
47948     }
regions(mut self, regions: &'a [ImageResolve2KHR]) -> ResolveImageInfo2KHRBuilder<'a>47949     pub fn regions(mut self, regions: &'a [ImageResolve2KHR]) -> ResolveImageInfo2KHRBuilder<'a> {
47950         self.inner.region_count = regions.len() as _;
47951         self.inner.p_regions = regions.as_ptr();
47952         self
47953     }
47954     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
47955     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
47956     #[doc = r" valid extension structs can be pushed into the chain."]
47957     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
47958     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsResolveImageInfo2KHR>( mut self, next: &'a mut T, ) -> ResolveImageInfo2KHRBuilder<'a>47959     pub fn push_next<T: ExtendsResolveImageInfo2KHR>(
47960         mut self,
47961         next: &'a mut T,
47962     ) -> ResolveImageInfo2KHRBuilder<'a> {
47963         unsafe {
47964             let next_ptr = next as *mut T as *mut BaseOutStructure;
47965             let last_next = ptr_chain_iter(next).last().unwrap();
47966             (*last_next).p_next = self.inner.p_next as _;
47967             self.inner.p_next = next_ptr as _;
47968         }
47969         self
47970     }
47971     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
47972     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
47973     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> ResolveImageInfo2KHR47974     pub fn build(self) -> ResolveImageInfo2KHR {
47975         self.inner
47976     }
47977 }
47978 #[repr(C)]
47979 #[derive(Copy, Clone, Debug)]
47980 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html>"]
47981 pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
47982     pub s_type: StructureType,
47983     pub p_next: *mut c_void,
47984     pub shader_image_int64_atomics: Bool32,
47985     pub sparse_image_int64_atomics: Bool32,
47986 }
47987 impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
default() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT47988     fn default() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
47989         PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
47990             s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
47991             p_next: ::std::ptr::null_mut(),
47992             shader_image_int64_atomics: Bool32::default(),
47993             sparse_image_int64_atomics: Bool32::default(),
47994         }
47995     }
47996 }
47997 impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a>47998     pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
47999         PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder {
48000             inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::default(),
48001             marker: ::std::marker::PhantomData,
48002         }
48003     }
48004 }
48005 #[repr(transparent)]
48006 pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
48007     inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT,
48008     marker: ::std::marker::PhantomData<&'a ()>,
48009 }
48010 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {}
48011 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {}
48012 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
48013     type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
deref(&self) -> &Self::Target48014     fn deref(&self) -> &Self::Target {
48015         &self.inner
48016     }
48017 }
48018 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48019     fn deref_mut(&mut self) -> &mut Self::Target {
48020         &mut self.inner
48021     }
48022 }
48023 impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
shader_image_int64_atomics( mut self, shader_image_int64_atomics: bool, ) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a>48024     pub fn shader_image_int64_atomics(
48025         mut self,
48026         shader_image_int64_atomics: bool,
48027     ) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
48028         self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into();
48029         self
48030     }
sparse_image_int64_atomics( mut self, sparse_image_int64_atomics: bool, ) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a>48031     pub fn sparse_image_int64_atomics(
48032         mut self,
48033         sparse_image_int64_atomics: bool,
48034     ) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
48035         self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into();
48036         self
48037     }
48038     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48039     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48040     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT48041     pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
48042         self.inner
48043     }
48044 }
48045 #[repr(C)]
48046 #[derive(Copy, Clone, Debug)]
48047 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFragmentShadingRateAttachmentInfoKHR.html>"]
48048 pub struct FragmentShadingRateAttachmentInfoKHR {
48049     pub s_type: StructureType,
48050     pub p_next: *const c_void,
48051     pub p_fragment_shading_rate_attachment: *const AttachmentReference2,
48052     pub shading_rate_attachment_texel_size: Extent2D,
48053 }
48054 impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR {
default() -> FragmentShadingRateAttachmentInfoKHR48055     fn default() -> FragmentShadingRateAttachmentInfoKHR {
48056         FragmentShadingRateAttachmentInfoKHR {
48057             s_type: StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
48058             p_next: ::std::ptr::null(),
48059             p_fragment_shading_rate_attachment: ::std::ptr::null(),
48060             shading_rate_attachment_texel_size: Extent2D::default(),
48061         }
48062     }
48063 }
48064 impl FragmentShadingRateAttachmentInfoKHR {
builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a>48065     pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
48066         FragmentShadingRateAttachmentInfoKHRBuilder {
48067             inner: FragmentShadingRateAttachmentInfoKHR::default(),
48068             marker: ::std::marker::PhantomData,
48069         }
48070     }
48071 }
48072 #[repr(transparent)]
48073 pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
48074     inner: FragmentShadingRateAttachmentInfoKHR,
48075     marker: ::std::marker::PhantomData<&'a ()>,
48076 }
48077 unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
48078 unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {}
48079 impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
48080     type Target = FragmentShadingRateAttachmentInfoKHR;
deref(&self) -> &Self::Target48081     fn deref(&self) -> &Self::Target {
48082         &self.inner
48083     }
48084 }
48085 impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48086     fn deref_mut(&mut self) -> &mut Self::Target {
48087         &mut self.inner
48088     }
48089 }
48090 impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
fragment_shading_rate_attachment( mut self, fragment_shading_rate_attachment: &'a AttachmentReference2, ) -> FragmentShadingRateAttachmentInfoKHRBuilder<'a>48091     pub fn fragment_shading_rate_attachment(
48092         mut self,
48093         fragment_shading_rate_attachment: &'a AttachmentReference2,
48094     ) -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
48095         self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment;
48096         self
48097     }
shading_rate_attachment_texel_size( mut self, shading_rate_attachment_texel_size: Extent2D, ) -> FragmentShadingRateAttachmentInfoKHRBuilder<'a>48098     pub fn shading_rate_attachment_texel_size(
48099         mut self,
48100         shading_rate_attachment_texel_size: Extent2D,
48101     ) -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
48102         self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
48103         self
48104     }
48105     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48106     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48107     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> FragmentShadingRateAttachmentInfoKHR48108     pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR {
48109         self.inner
48110     }
48111 }
48112 #[repr(C)]
48113 #[derive(Copy, Clone, Debug)]
48114 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html>"]
48115 pub struct PipelineFragmentShadingRateStateCreateInfoKHR {
48116     pub s_type: StructureType,
48117     pub p_next: *const c_void,
48118     pub fragment_size: Extent2D,
48119     pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
48120 }
48121 impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR {
default() -> PipelineFragmentShadingRateStateCreateInfoKHR48122     fn default() -> PipelineFragmentShadingRateStateCreateInfoKHR {
48123         PipelineFragmentShadingRateStateCreateInfoKHR {
48124             s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
48125             p_next: ::std::ptr::null(),
48126             fragment_size: Extent2D::default(),
48127             combiner_ops: unsafe { ::std::mem::zeroed() },
48128         }
48129     }
48130 }
48131 impl PipelineFragmentShadingRateStateCreateInfoKHR {
builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a>48132     pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
48133         PipelineFragmentShadingRateStateCreateInfoKHRBuilder {
48134             inner: PipelineFragmentShadingRateStateCreateInfoKHR::default(),
48135             marker: ::std::marker::PhantomData,
48136         }
48137     }
48138 }
48139 #[repr(transparent)]
48140 pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
48141     inner: PipelineFragmentShadingRateStateCreateInfoKHR,
48142     marker: ::std::marker::PhantomData<&'a ()>,
48143 }
48144 unsafe impl ExtendsGraphicsPipelineCreateInfo
48145     for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_>
48146 {
48147 }
48148 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {}
48149 impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
48150     type Target = PipelineFragmentShadingRateStateCreateInfoKHR;
deref(&self) -> &Self::Target48151     fn deref(&self) -> &Self::Target {
48152         &self.inner
48153     }
48154 }
48155 impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48156     fn deref_mut(&mut self) -> &mut Self::Target {
48157         &mut self.inner
48158     }
48159 }
48160 impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
fragment_size( mut self, fragment_size: Extent2D, ) -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a>48161     pub fn fragment_size(
48162         mut self,
48163         fragment_size: Extent2D,
48164     ) -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
48165         self.inner.fragment_size = fragment_size;
48166         self
48167     }
combiner_ops( mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], ) -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a>48168     pub fn combiner_ops(
48169         mut self,
48170         combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
48171     ) -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
48172         self.inner.combiner_ops = combiner_ops;
48173         self
48174     }
48175     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48176     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48177     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR48178     pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR {
48179         self.inner
48180     }
48181 }
48182 #[repr(C)]
48183 #[derive(Copy, Clone, Debug)]
48184 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html>"]
48185 pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
48186     pub s_type: StructureType,
48187     pub p_next: *mut c_void,
48188     pub pipeline_fragment_shading_rate: Bool32,
48189     pub primitive_fragment_shading_rate: Bool32,
48190     pub attachment_fragment_shading_rate: Bool32,
48191 }
48192 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR {
default() -> PhysicalDeviceFragmentShadingRateFeaturesKHR48193     fn default() -> PhysicalDeviceFragmentShadingRateFeaturesKHR {
48194         PhysicalDeviceFragmentShadingRateFeaturesKHR {
48195             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,
48196             p_next: ::std::ptr::null_mut(),
48197             pipeline_fragment_shading_rate: Bool32::default(),
48198             primitive_fragment_shading_rate: Bool32::default(),
48199             attachment_fragment_shading_rate: Bool32::default(),
48200         }
48201     }
48202 }
48203 impl PhysicalDeviceFragmentShadingRateFeaturesKHR {
builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a>48204     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
48205         PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder {
48206             inner: PhysicalDeviceFragmentShadingRateFeaturesKHR::default(),
48207             marker: ::std::marker::PhantomData,
48208         }
48209     }
48210 }
48211 #[repr(transparent)]
48212 pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
48213     inner: PhysicalDeviceFragmentShadingRateFeaturesKHR,
48214     marker: ::std::marker::PhantomData<&'a ()>,
48215 }
48216 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {}
48217 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {}
48218 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
48219     type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR;
deref(&self) -> &Self::Target48220     fn deref(&self) -> &Self::Target {
48221         &self.inner
48222     }
48223 }
48224 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48225     fn deref_mut(&mut self) -> &mut Self::Target {
48226         &mut self.inner
48227     }
48228 }
48229 impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
pipeline_fragment_shading_rate( mut self, pipeline_fragment_shading_rate: bool, ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a>48230     pub fn pipeline_fragment_shading_rate(
48231         mut self,
48232         pipeline_fragment_shading_rate: bool,
48233     ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
48234         self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into();
48235         self
48236     }
primitive_fragment_shading_rate( mut self, primitive_fragment_shading_rate: bool, ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a>48237     pub fn primitive_fragment_shading_rate(
48238         mut self,
48239         primitive_fragment_shading_rate: bool,
48240     ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
48241         self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into();
48242         self
48243     }
attachment_fragment_shading_rate( mut self, attachment_fragment_shading_rate: bool, ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a>48244     pub fn attachment_fragment_shading_rate(
48245         mut self,
48246         attachment_fragment_shading_rate: bool,
48247     ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
48248         self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into();
48249         self
48250     }
48251     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48252     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48253     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR48254     pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR {
48255         self.inner
48256     }
48257 }
48258 #[repr(C)]
48259 #[derive(Copy, Clone, Debug)]
48260 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html>"]
48261 pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
48262     pub s_type: StructureType,
48263     pub p_next: *mut c_void,
48264     pub min_fragment_shading_rate_attachment_texel_size: Extent2D,
48265     pub max_fragment_shading_rate_attachment_texel_size: Extent2D,
48266     pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
48267     pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32,
48268     pub layered_shading_rate_attachments: Bool32,
48269     pub fragment_shading_rate_non_trivial_combiner_ops: Bool32,
48270     pub max_fragment_size: Extent2D,
48271     pub max_fragment_size_aspect_ratio: u32,
48272     pub max_fragment_shading_rate_coverage_samples: u32,
48273     pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
48274     pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32,
48275     pub fragment_shading_rate_with_sample_mask: Bool32,
48276     pub fragment_shading_rate_with_shader_sample_mask: Bool32,
48277     pub fragment_shading_rate_with_conservative_rasterization: Bool32,
48278     pub fragment_shading_rate_with_fragment_shader_interlock: Bool32,
48279     pub fragment_shading_rate_with_custom_sample_locations: Bool32,
48280     pub fragment_shading_rate_strict_multiply_combiner: Bool32,
48281 }
48282 impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR {
default() -> PhysicalDeviceFragmentShadingRatePropertiesKHR48283     fn default() -> PhysicalDeviceFragmentShadingRatePropertiesKHR {
48284         PhysicalDeviceFragmentShadingRatePropertiesKHR {
48285             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR,
48286             p_next: ::std::ptr::null_mut(),
48287             min_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
48288             max_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
48289             max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(),
48290             primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(),
48291             layered_shading_rate_attachments: Bool32::default(),
48292             fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(),
48293             max_fragment_size: Extent2D::default(),
48294             max_fragment_size_aspect_ratio: u32::default(),
48295             max_fragment_shading_rate_coverage_samples: u32::default(),
48296             max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(),
48297             fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(),
48298             fragment_shading_rate_with_sample_mask: Bool32::default(),
48299             fragment_shading_rate_with_shader_sample_mask: Bool32::default(),
48300             fragment_shading_rate_with_conservative_rasterization: Bool32::default(),
48301             fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(),
48302             fragment_shading_rate_with_custom_sample_locations: Bool32::default(),
48303             fragment_shading_rate_strict_multiply_combiner: Bool32::default(),
48304         }
48305     }
48306 }
48307 impl PhysicalDeviceFragmentShadingRatePropertiesKHR {
builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48308     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48309         PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder {
48310             inner: PhysicalDeviceFragmentShadingRatePropertiesKHR::default(),
48311             marker: ::std::marker::PhantomData,
48312         }
48313     }
48314 }
48315 #[repr(transparent)]
48316 pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48317     inner: PhysicalDeviceFragmentShadingRatePropertiesKHR,
48318     marker: ::std::marker::PhantomData<&'a ()>,
48319 }
48320 unsafe impl ExtendsPhysicalDeviceProperties2
48321     for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_>
48322 {
48323 }
48324 unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {}
48325 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48326     type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR;
deref(&self) -> &Self::Target48327     fn deref(&self) -> &Self::Target {
48328         &self.inner
48329     }
48330 }
48331 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48332     fn deref_mut(&mut self) -> &mut Self::Target {
48333         &mut self.inner
48334     }
48335 }
48336 impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
min_fragment_shading_rate_attachment_texel_size( mut self, min_fragment_shading_rate_attachment_texel_size: Extent2D, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48337     pub fn min_fragment_shading_rate_attachment_texel_size(
48338         mut self,
48339         min_fragment_shading_rate_attachment_texel_size: Extent2D,
48340     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48341         self.inner.min_fragment_shading_rate_attachment_texel_size =
48342             min_fragment_shading_rate_attachment_texel_size;
48343         self
48344     }
max_fragment_shading_rate_attachment_texel_size( mut self, max_fragment_shading_rate_attachment_texel_size: Extent2D, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48345     pub fn max_fragment_shading_rate_attachment_texel_size(
48346         mut self,
48347         max_fragment_shading_rate_attachment_texel_size: Extent2D,
48348     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48349         self.inner.max_fragment_shading_rate_attachment_texel_size =
48350             max_fragment_shading_rate_attachment_texel_size;
48351         self
48352     }
max_fragment_shading_rate_attachment_texel_size_aspect_ratio( mut self, max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48353     pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio(
48354         mut self,
48355         max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
48356     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48357         self.inner
48358             .max_fragment_shading_rate_attachment_texel_size_aspect_ratio =
48359             max_fragment_shading_rate_attachment_texel_size_aspect_ratio;
48360         self
48361     }
primitive_fragment_shading_rate_with_multiple_viewports( mut self, primitive_fragment_shading_rate_with_multiple_viewports: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48362     pub fn primitive_fragment_shading_rate_with_multiple_viewports(
48363         mut self,
48364         primitive_fragment_shading_rate_with_multiple_viewports: bool,
48365     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48366         self.inner
48367             .primitive_fragment_shading_rate_with_multiple_viewports =
48368             primitive_fragment_shading_rate_with_multiple_viewports.into();
48369         self
48370     }
layered_shading_rate_attachments( mut self, layered_shading_rate_attachments: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48371     pub fn layered_shading_rate_attachments(
48372         mut self,
48373         layered_shading_rate_attachments: bool,
48374     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48375         self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into();
48376         self
48377     }
fragment_shading_rate_non_trivial_combiner_ops( mut self, fragment_shading_rate_non_trivial_combiner_ops: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48378     pub fn fragment_shading_rate_non_trivial_combiner_ops(
48379         mut self,
48380         fragment_shading_rate_non_trivial_combiner_ops: bool,
48381     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48382         self.inner.fragment_shading_rate_non_trivial_combiner_ops =
48383             fragment_shading_rate_non_trivial_combiner_ops.into();
48384         self
48385     }
max_fragment_size( mut self, max_fragment_size: Extent2D, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48386     pub fn max_fragment_size(
48387         mut self,
48388         max_fragment_size: Extent2D,
48389     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48390         self.inner.max_fragment_size = max_fragment_size;
48391         self
48392     }
max_fragment_size_aspect_ratio( mut self, max_fragment_size_aspect_ratio: u32, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48393     pub fn max_fragment_size_aspect_ratio(
48394         mut self,
48395         max_fragment_size_aspect_ratio: u32,
48396     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48397         self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio;
48398         self
48399     }
max_fragment_shading_rate_coverage_samples( mut self, max_fragment_shading_rate_coverage_samples: u32, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48400     pub fn max_fragment_shading_rate_coverage_samples(
48401         mut self,
48402         max_fragment_shading_rate_coverage_samples: u32,
48403     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48404         self.inner.max_fragment_shading_rate_coverage_samples =
48405             max_fragment_shading_rate_coverage_samples;
48406         self
48407     }
max_fragment_shading_rate_rasterization_samples( mut self, max_fragment_shading_rate_rasterization_samples: SampleCountFlags, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48408     pub fn max_fragment_shading_rate_rasterization_samples(
48409         mut self,
48410         max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
48411     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48412         self.inner.max_fragment_shading_rate_rasterization_samples =
48413             max_fragment_shading_rate_rasterization_samples;
48414         self
48415     }
fragment_shading_rate_with_shader_depth_stencil_writes( mut self, fragment_shading_rate_with_shader_depth_stencil_writes: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48416     pub fn fragment_shading_rate_with_shader_depth_stencil_writes(
48417         mut self,
48418         fragment_shading_rate_with_shader_depth_stencil_writes: bool,
48419     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48420         self.inner
48421             .fragment_shading_rate_with_shader_depth_stencil_writes =
48422             fragment_shading_rate_with_shader_depth_stencil_writes.into();
48423         self
48424     }
fragment_shading_rate_with_sample_mask( mut self, fragment_shading_rate_with_sample_mask: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48425     pub fn fragment_shading_rate_with_sample_mask(
48426         mut self,
48427         fragment_shading_rate_with_sample_mask: bool,
48428     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48429         self.inner.fragment_shading_rate_with_sample_mask =
48430             fragment_shading_rate_with_sample_mask.into();
48431         self
48432     }
fragment_shading_rate_with_shader_sample_mask( mut self, fragment_shading_rate_with_shader_sample_mask: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48433     pub fn fragment_shading_rate_with_shader_sample_mask(
48434         mut self,
48435         fragment_shading_rate_with_shader_sample_mask: bool,
48436     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48437         self.inner.fragment_shading_rate_with_shader_sample_mask =
48438             fragment_shading_rate_with_shader_sample_mask.into();
48439         self
48440     }
fragment_shading_rate_with_conservative_rasterization( mut self, fragment_shading_rate_with_conservative_rasterization: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48441     pub fn fragment_shading_rate_with_conservative_rasterization(
48442         mut self,
48443         fragment_shading_rate_with_conservative_rasterization: bool,
48444     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48445         self.inner
48446             .fragment_shading_rate_with_conservative_rasterization =
48447             fragment_shading_rate_with_conservative_rasterization.into();
48448         self
48449     }
fragment_shading_rate_with_fragment_shader_interlock( mut self, fragment_shading_rate_with_fragment_shader_interlock: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48450     pub fn fragment_shading_rate_with_fragment_shader_interlock(
48451         mut self,
48452         fragment_shading_rate_with_fragment_shader_interlock: bool,
48453     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48454         self.inner
48455             .fragment_shading_rate_with_fragment_shader_interlock =
48456             fragment_shading_rate_with_fragment_shader_interlock.into();
48457         self
48458     }
fragment_shading_rate_with_custom_sample_locations( mut self, fragment_shading_rate_with_custom_sample_locations: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48459     pub fn fragment_shading_rate_with_custom_sample_locations(
48460         mut self,
48461         fragment_shading_rate_with_custom_sample_locations: bool,
48462     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48463         self.inner
48464             .fragment_shading_rate_with_custom_sample_locations =
48465             fragment_shading_rate_with_custom_sample_locations.into();
48466         self
48467     }
fragment_shading_rate_strict_multiply_combiner( mut self, fragment_shading_rate_strict_multiply_combiner: bool, ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a>48468     pub fn fragment_shading_rate_strict_multiply_combiner(
48469         mut self,
48470         fragment_shading_rate_strict_multiply_combiner: bool,
48471     ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
48472         self.inner.fragment_shading_rate_strict_multiply_combiner =
48473             fragment_shading_rate_strict_multiply_combiner.into();
48474         self
48475     }
48476     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48477     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48478     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR48479     pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR {
48480         self.inner
48481     }
48482 }
48483 #[repr(C)]
48484 #[derive(Copy, Clone, Debug)]
48485 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html>"]
48486 pub struct PhysicalDeviceFragmentShadingRateKHR {
48487     pub s_type: StructureType,
48488     pub p_next: *mut c_void,
48489     pub sample_counts: SampleCountFlags,
48490     pub fragment_size: Extent2D,
48491 }
48492 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR {
default() -> PhysicalDeviceFragmentShadingRateKHR48493     fn default() -> PhysicalDeviceFragmentShadingRateKHR {
48494         PhysicalDeviceFragmentShadingRateKHR {
48495             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
48496             p_next: ::std::ptr::null_mut(),
48497             sample_counts: SampleCountFlags::default(),
48498             fragment_size: Extent2D::default(),
48499         }
48500     }
48501 }
48502 impl PhysicalDeviceFragmentShadingRateKHR {
builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a>48503     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
48504         PhysicalDeviceFragmentShadingRateKHRBuilder {
48505             inner: PhysicalDeviceFragmentShadingRateKHR::default(),
48506             marker: ::std::marker::PhantomData,
48507         }
48508     }
48509 }
48510 #[repr(transparent)]
48511 pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
48512     inner: PhysicalDeviceFragmentShadingRateKHR,
48513     marker: ::std::marker::PhantomData<&'a ()>,
48514 }
48515 pub unsafe trait ExtendsPhysicalDeviceFragmentShadingRateKHR {}
48516 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
48517     type Target = PhysicalDeviceFragmentShadingRateKHR;
deref(&self) -> &Self::Target48518     fn deref(&self) -> &Self::Target {
48519         &self.inner
48520     }
48521 }
48522 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48523     fn deref_mut(&mut self) -> &mut Self::Target {
48524         &mut self.inner
48525     }
48526 }
48527 impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
sample_counts( mut self, sample_counts: SampleCountFlags, ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a>48528     pub fn sample_counts(
48529         mut self,
48530         sample_counts: SampleCountFlags,
48531     ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
48532         self.inner.sample_counts = sample_counts;
48533         self
48534     }
fragment_size( mut self, fragment_size: Extent2D, ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a>48535     pub fn fragment_size(
48536         mut self,
48537         fragment_size: Extent2D,
48538     ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
48539         self.inner.fragment_size = fragment_size;
48540         self
48541     }
48542     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48543     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48544     #[doc = r" valid extension structs can be pushed into the chain."]
48545     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48546     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsPhysicalDeviceFragmentShadingRateKHR>( mut self, next: &'a mut T, ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a>48547     pub fn push_next<T: ExtendsPhysicalDeviceFragmentShadingRateKHR>(
48548         mut self,
48549         next: &'a mut T,
48550     ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
48551         unsafe {
48552             let next_ptr = next as *mut T as *mut BaseOutStructure;
48553             let last_next = ptr_chain_iter(next).last().unwrap();
48554             (*last_next).p_next = self.inner.p_next as _;
48555             self.inner.p_next = next_ptr as _;
48556         }
48557         self
48558     }
48559     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48560     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48561     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateKHR48562     pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR {
48563         self.inner
48564     }
48565 }
48566 #[repr(C)]
48567 #[derive(Copy, Clone, Debug)]
48568 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.html>"]
48569 pub struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
48570     pub s_type: StructureType,
48571     pub p_next: *mut c_void,
48572     pub shader_terminate_invocation: Bool32,
48573 }
48574 impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
default() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR48575     fn default() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
48576         PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
48577             s_type: StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR,
48578             p_next: ::std::ptr::null_mut(),
48579             shader_terminate_invocation: Bool32::default(),
48580         }
48581     }
48582 }
48583 impl PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a>48584     pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
48585         PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder {
48586             inner: PhysicalDeviceShaderTerminateInvocationFeaturesKHR::default(),
48587             marker: ::std::marker::PhantomData,
48588         }
48589     }
48590 }
48591 #[repr(transparent)]
48592 pub struct PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
48593     inner: PhysicalDeviceShaderTerminateInvocationFeaturesKHR,
48594     marker: ::std::marker::PhantomData<&'a ()>,
48595 }
48596 unsafe impl ExtendsDeviceCreateInfo
48597     for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'_>
48598 {
48599 }
48600 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesKHR {}
48601 impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
48602     type Target = PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
deref(&self) -> &Self::Target48603     fn deref(&self) -> &Self::Target {
48604         &self.inner
48605     }
48606 }
48607 impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48608     fn deref_mut(&mut self) -> &mut Self::Target {
48609         &mut self.inner
48610     }
48611 }
48612 impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
shader_terminate_invocation( mut self, shader_terminate_invocation: bool, ) -> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a>48613     pub fn shader_terminate_invocation(
48614         mut self,
48615         shader_terminate_invocation: bool,
48616     ) -> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
48617         self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
48618         self
48619     }
48620     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48621     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48622     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR48623     pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
48624         self.inner
48625     }
48626 }
48627 #[repr(C)]
48628 #[derive(Copy, Clone, Debug)]
48629 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html>"]
48630 pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
48631     pub s_type: StructureType,
48632     pub p_next: *mut c_void,
48633     pub fragment_shading_rate_enums: Bool32,
48634     pub supersample_fragment_shading_rates: Bool32,
48635     pub no_invocation_fragment_shading_rates: Bool32,
48636 }
48637 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
default() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV48638     fn default() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
48639         PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
48640             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV,
48641             p_next: ::std::ptr::null_mut(),
48642             fragment_shading_rate_enums: Bool32::default(),
48643             supersample_fragment_shading_rates: Bool32::default(),
48644             no_invocation_fragment_shading_rates: Bool32::default(),
48645         }
48646     }
48647 }
48648 impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a>48649     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
48650         PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder {
48651             inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::default(),
48652             marker: ::std::marker::PhantomData,
48653         }
48654     }
48655 }
48656 #[repr(transparent)]
48657 pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
48658     inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV,
48659     marker: ::std::marker::PhantomData<&'a ()>,
48660 }
48661 unsafe impl ExtendsDeviceCreateInfo
48662     for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_>
48663 {
48664 }
48665 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {}
48666 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
48667     type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
deref(&self) -> &Self::Target48668     fn deref(&self) -> &Self::Target {
48669         &self.inner
48670     }
48671 }
48672 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48673     fn deref_mut(&mut self) -> &mut Self::Target {
48674         &mut self.inner
48675     }
48676 }
48677 impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
fragment_shading_rate_enums( mut self, fragment_shading_rate_enums: bool, ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a>48678     pub fn fragment_shading_rate_enums(
48679         mut self,
48680         fragment_shading_rate_enums: bool,
48681     ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
48682         self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into();
48683         self
48684     }
supersample_fragment_shading_rates( mut self, supersample_fragment_shading_rates: bool, ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a>48685     pub fn supersample_fragment_shading_rates(
48686         mut self,
48687         supersample_fragment_shading_rates: bool,
48688     ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
48689         self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into();
48690         self
48691     }
no_invocation_fragment_shading_rates( mut self, no_invocation_fragment_shading_rates: bool, ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a>48692     pub fn no_invocation_fragment_shading_rates(
48693         mut self,
48694         no_invocation_fragment_shading_rates: bool,
48695     ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
48696         self.inner.no_invocation_fragment_shading_rates =
48697             no_invocation_fragment_shading_rates.into();
48698         self
48699     }
48700     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48701     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48702     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV48703     pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
48704         self.inner
48705     }
48706 }
48707 #[repr(C)]
48708 #[derive(Copy, Clone, Debug)]
48709 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html>"]
48710 pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
48711     pub s_type: StructureType,
48712     pub p_next: *mut c_void,
48713     pub max_fragment_shading_rate_invocation_count: SampleCountFlags,
48714 }
48715 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
default() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV48716     fn default() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
48717         PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
48718             s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV,
48719             p_next: ::std::ptr::null_mut(),
48720             max_fragment_shading_rate_invocation_count: SampleCountFlags::default(),
48721         }
48722     }
48723 }
48724 impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a>48725     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
48726         PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder {
48727             inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::default(),
48728             marker: ::std::marker::PhantomData,
48729         }
48730     }
48731 }
48732 #[repr(transparent)]
48733 pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
48734     inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV,
48735     marker: ::std::marker::PhantomData<&'a ()>,
48736 }
48737 unsafe impl ExtendsPhysicalDeviceProperties2
48738     for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_>
48739 {
48740 }
48741 unsafe impl ExtendsPhysicalDeviceProperties2
48742     for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
48743 {
48744 }
48745 impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
48746     type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
deref(&self) -> &Self::Target48747     fn deref(&self) -> &Self::Target {
48748         &self.inner
48749     }
48750 }
48751 impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48752     fn deref_mut(&mut self) -> &mut Self::Target {
48753         &mut self.inner
48754     }
48755 }
48756 impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
max_fragment_shading_rate_invocation_count( mut self, max_fragment_shading_rate_invocation_count: SampleCountFlags, ) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a>48757     pub fn max_fragment_shading_rate_invocation_count(
48758         mut self,
48759         max_fragment_shading_rate_invocation_count: SampleCountFlags,
48760     ) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
48761         self.inner.max_fragment_shading_rate_invocation_count =
48762             max_fragment_shading_rate_invocation_count;
48763         self
48764     }
48765     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48766     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48767     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV48768     pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
48769         self.inner
48770     }
48771 }
48772 #[repr(C)]
48773 #[derive(Copy, Clone, Debug)]
48774 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html>"]
48775 pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
48776     pub s_type: StructureType,
48777     pub p_next: *const c_void,
48778     pub shading_rate_type: FragmentShadingRateTypeNV,
48779     pub shading_rate: FragmentShadingRateNV,
48780     pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
48781 }
48782 impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV {
default() -> PipelineFragmentShadingRateEnumStateCreateInfoNV48783     fn default() -> PipelineFragmentShadingRateEnumStateCreateInfoNV {
48784         PipelineFragmentShadingRateEnumStateCreateInfoNV {
48785             s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV,
48786             p_next: ::std::ptr::null(),
48787             shading_rate_type: FragmentShadingRateTypeNV::default(),
48788             shading_rate: FragmentShadingRateNV::default(),
48789             combiner_ops: unsafe { ::std::mem::zeroed() },
48790         }
48791     }
48792 }
48793 impl PipelineFragmentShadingRateEnumStateCreateInfoNV {
builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a>48794     pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
48795         PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder {
48796             inner: PipelineFragmentShadingRateEnumStateCreateInfoNV::default(),
48797             marker: ::std::marker::PhantomData,
48798         }
48799     }
48800 }
48801 #[repr(transparent)]
48802 pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
48803     inner: PipelineFragmentShadingRateEnumStateCreateInfoNV,
48804     marker: ::std::marker::PhantomData<&'a ()>,
48805 }
48806 unsafe impl ExtendsGraphicsPipelineCreateInfo
48807     for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_>
48808 {
48809 }
48810 unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {}
48811 impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
48812     type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV;
deref(&self) -> &Self::Target48813     fn deref(&self) -> &Self::Target {
48814         &self.inner
48815     }
48816 }
48817 impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48818     fn deref_mut(&mut self) -> &mut Self::Target {
48819         &mut self.inner
48820     }
48821 }
48822 impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
shading_rate_type( mut self, shading_rate_type: FragmentShadingRateTypeNV, ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a>48823     pub fn shading_rate_type(
48824         mut self,
48825         shading_rate_type: FragmentShadingRateTypeNV,
48826     ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
48827         self.inner.shading_rate_type = shading_rate_type;
48828         self
48829     }
shading_rate( mut self, shading_rate: FragmentShadingRateNV, ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a>48830     pub fn shading_rate(
48831         mut self,
48832         shading_rate: FragmentShadingRateNV,
48833     ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
48834         self.inner.shading_rate = shading_rate;
48835         self
48836     }
combiner_ops( mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a>48837     pub fn combiner_ops(
48838         mut self,
48839         combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
48840     ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
48841         self.inner.combiner_ops = combiner_ops;
48842         self
48843     }
48844     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48845     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48846     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV48847     pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV {
48848         self.inner
48849     }
48850 }
48851 #[repr(C)]
48852 #[derive(Copy, Clone, Debug)]
48853 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildSizesInfoKHR.html>"]
48854 pub struct AccelerationStructureBuildSizesInfoKHR {
48855     pub s_type: StructureType,
48856     pub p_next: *const c_void,
48857     pub acceleration_structure_size: DeviceSize,
48858     pub update_scratch_size: DeviceSize,
48859     pub build_scratch_size: DeviceSize,
48860 }
48861 impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR {
default() -> AccelerationStructureBuildSizesInfoKHR48862     fn default() -> AccelerationStructureBuildSizesInfoKHR {
48863         AccelerationStructureBuildSizesInfoKHR {
48864             s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
48865             p_next: ::std::ptr::null(),
48866             acceleration_structure_size: DeviceSize::default(),
48867             update_scratch_size: DeviceSize::default(),
48868             build_scratch_size: DeviceSize::default(),
48869         }
48870     }
48871 }
48872 impl AccelerationStructureBuildSizesInfoKHR {
builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a>48873     pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
48874         AccelerationStructureBuildSizesInfoKHRBuilder {
48875             inner: AccelerationStructureBuildSizesInfoKHR::default(),
48876             marker: ::std::marker::PhantomData,
48877         }
48878     }
48879 }
48880 #[repr(transparent)]
48881 pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
48882     inner: AccelerationStructureBuildSizesInfoKHR,
48883     marker: ::std::marker::PhantomData<&'a ()>,
48884 }
48885 pub unsafe trait ExtendsAccelerationStructureBuildSizesInfoKHR {}
48886 impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
48887     type Target = AccelerationStructureBuildSizesInfoKHR;
deref(&self) -> &Self::Target48888     fn deref(&self) -> &Self::Target {
48889         &self.inner
48890     }
48891 }
48892 impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48893     fn deref_mut(&mut self) -> &mut Self::Target {
48894         &mut self.inner
48895     }
48896 }
48897 impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
acceleration_structure_size( mut self, acceleration_structure_size: DeviceSize, ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a>48898     pub fn acceleration_structure_size(
48899         mut self,
48900         acceleration_structure_size: DeviceSize,
48901     ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
48902         self.inner.acceleration_structure_size = acceleration_structure_size;
48903         self
48904     }
update_scratch_size( mut self, update_scratch_size: DeviceSize, ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a>48905     pub fn update_scratch_size(
48906         mut self,
48907         update_scratch_size: DeviceSize,
48908     ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
48909         self.inner.update_scratch_size = update_scratch_size;
48910         self
48911     }
build_scratch_size( mut self, build_scratch_size: DeviceSize, ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a>48912     pub fn build_scratch_size(
48913         mut self,
48914         build_scratch_size: DeviceSize,
48915     ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
48916         self.inner.build_scratch_size = build_scratch_size;
48917         self
48918     }
48919     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
48920     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
48921     #[doc = r" valid extension structs can be pushed into the chain."]
48922     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
48923     #[doc = r" chain will look like `A -> D -> B -> C`."]
push_next<T: ExtendsAccelerationStructureBuildSizesInfoKHR>( mut self, next: &'a mut T, ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a>48924     pub fn push_next<T: ExtendsAccelerationStructureBuildSizesInfoKHR>(
48925         mut self,
48926         next: &'a mut T,
48927     ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
48928         unsafe {
48929             let next_ptr = next as *mut T as *mut BaseOutStructure;
48930             let last_next = ptr_chain_iter(next).last().unwrap();
48931             (*last_next).p_next = self.inner.p_next as _;
48932             self.inner.p_next = next_ptr as _;
48933         }
48934         self
48935     }
48936     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48937     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48938     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> AccelerationStructureBuildSizesInfoKHR48939     pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR {
48940         self.inner
48941     }
48942 }
48943 #[repr(C)]
48944 #[derive(Copy, Clone, Debug)]
48945 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html>"]
48946 pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
48947     pub s_type: StructureType,
48948     pub p_next: *mut c_void,
48949     pub mutable_descriptor_type: Bool32,
48950 }
48951 impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
default() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE48952     fn default() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
48953         PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
48954             s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
48955             p_next: ::std::ptr::null_mut(),
48956             mutable_descriptor_type: Bool32::default(),
48957         }
48958     }
48959 }
48960 impl PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a>48961     pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
48962         PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder {
48963             inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE::default(),
48964             marker: ::std::marker::PhantomData,
48965         }
48966     }
48967 }
48968 #[repr(transparent)]
48969 pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
48970     inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE,
48971     marker: ::std::marker::PhantomData<&'a ()>,
48972 }
48973 unsafe impl ExtendsDeviceCreateInfo
48974     for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
48975 {
48976 }
48977 unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
48978 impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
48979     type Target = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
deref(&self) -> &Self::Target48980     fn deref(&self) -> &Self::Target {
48981         &self.inner
48982     }
48983 }
48984 impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target48985     fn deref_mut(&mut self) -> &mut Self::Target {
48986         &mut self.inner
48987     }
48988 }
48989 impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
mutable_descriptor_type( mut self, mutable_descriptor_type: bool, ) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a>48990     pub fn mutable_descriptor_type(
48991         mut self,
48992         mutable_descriptor_type: bool,
48993     ) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
48994         self.inner.mutable_descriptor_type = mutable_descriptor_type.into();
48995         self
48996     }
48997     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
48998     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
48999     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE49000     pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
49001         self.inner
49002     }
49003 }
49004 #[repr(C)]
49005 #[derive(Copy, Clone, Debug)]
49006 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMutableDescriptorTypeListVALVE.html>"]
49007 pub struct MutableDescriptorTypeListVALVE {
49008     pub descriptor_type_count: u32,
49009     pub p_descriptor_types: *const DescriptorType,
49010 }
49011 impl ::std::default::Default for MutableDescriptorTypeListVALVE {
default() -> MutableDescriptorTypeListVALVE49012     fn default() -> MutableDescriptorTypeListVALVE {
49013         MutableDescriptorTypeListVALVE {
49014             descriptor_type_count: u32::default(),
49015             p_descriptor_types: ::std::ptr::null(),
49016         }
49017     }
49018 }
49019 impl MutableDescriptorTypeListVALVE {
builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a>49020     pub fn builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a> {
49021         MutableDescriptorTypeListVALVEBuilder {
49022             inner: MutableDescriptorTypeListVALVE::default(),
49023             marker: ::std::marker::PhantomData,
49024         }
49025     }
49026 }
49027 #[repr(transparent)]
49028 pub struct MutableDescriptorTypeListVALVEBuilder<'a> {
49029     inner: MutableDescriptorTypeListVALVE,
49030     marker: ::std::marker::PhantomData<&'a ()>,
49031 }
49032 impl<'a> ::std::ops::Deref for MutableDescriptorTypeListVALVEBuilder<'a> {
49033     type Target = MutableDescriptorTypeListVALVE;
deref(&self) -> &Self::Target49034     fn deref(&self) -> &Self::Target {
49035         &self.inner
49036     }
49037 }
49038 impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListVALVEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49039     fn deref_mut(&mut self) -> &mut Self::Target {
49040         &mut self.inner
49041     }
49042 }
49043 impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> {
descriptor_types( mut self, descriptor_types: &'a [DescriptorType], ) -> MutableDescriptorTypeListVALVEBuilder<'a>49044     pub fn descriptor_types(
49045         mut self,
49046         descriptor_types: &'a [DescriptorType],
49047     ) -> MutableDescriptorTypeListVALVEBuilder<'a> {
49048         self.inner.descriptor_type_count = descriptor_types.len() as _;
49049         self.inner.p_descriptor_types = descriptor_types.as_ptr();
49050         self
49051     }
49052     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49053     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49054     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MutableDescriptorTypeListVALVE49055     pub fn build(self) -> MutableDescriptorTypeListVALVE {
49056         self.inner
49057     }
49058 }
49059 #[repr(C)]
49060 #[derive(Copy, Clone, Debug)]
49061 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMutableDescriptorTypeCreateInfoVALVE.html>"]
49062 pub struct MutableDescriptorTypeCreateInfoVALVE {
49063     pub s_type: StructureType,
49064     pub p_next: *const c_void,
49065     pub mutable_descriptor_type_list_count: u32,
49066     pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE,
49067 }
49068 impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE {
default() -> MutableDescriptorTypeCreateInfoVALVE49069     fn default() -> MutableDescriptorTypeCreateInfoVALVE {
49070         MutableDescriptorTypeCreateInfoVALVE {
49071             s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
49072             p_next: ::std::ptr::null(),
49073             mutable_descriptor_type_list_count: u32::default(),
49074             p_mutable_descriptor_type_lists: ::std::ptr::null(),
49075         }
49076     }
49077 }
49078 impl MutableDescriptorTypeCreateInfoVALVE {
builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a>49079     pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
49080         MutableDescriptorTypeCreateInfoVALVEBuilder {
49081             inner: MutableDescriptorTypeCreateInfoVALVE::default(),
49082             marker: ::std::marker::PhantomData,
49083         }
49084     }
49085 }
49086 #[repr(transparent)]
49087 pub struct MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
49088     inner: MutableDescriptorTypeCreateInfoVALVE,
49089     marker: ::std::marker::PhantomData<&'a ()>,
49090 }
49091 unsafe impl ExtendsDescriptorSetLayoutCreateInfo
49092     for MutableDescriptorTypeCreateInfoVALVEBuilder<'_>
49093 {
49094 }
49095 unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
49096 unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> {}
49097 unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
49098 impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
49099     type Target = MutableDescriptorTypeCreateInfoVALVE;
deref(&self) -> &Self::Target49100     fn deref(&self) -> &Self::Target {
49101         &self.inner
49102     }
49103 }
49104 impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
deref_mut(&mut self) -> &mut Self::Target49105     fn deref_mut(&mut self) -> &mut Self::Target {
49106         &mut self.inner
49107     }
49108 }
49109 impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
mutable_descriptor_type_lists( mut self, mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE], ) -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a>49110     pub fn mutable_descriptor_type_lists(
49111         mut self,
49112         mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE],
49113     ) -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
49114         self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _;
49115         self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr();
49116         self
49117     }
49118     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
49119     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
49120     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
build(self) -> MutableDescriptorTypeCreateInfoVALVE49121     pub fn build(self) -> MutableDescriptorTypeCreateInfoVALVE {
49122         self.inner
49123     }
49124 }
49125